def test_get_extended_access_token_v23_plus():
mock_request.return_value.status_code = 200
mock_request.return_value.content = (
'{"access_token":"<extended access token>","token_type":"bearer"}'
)
access_token, expires_at = get_extended_access_token(
'<access token>',
'<application id>',
'<application secret key>',
api_version='2.3'
)
mock_request.assert_called_with(
'GET',
'https://graph.facebook.com/v2.3/oauth/access_token',
allow_redirects=True,
verify=True,
timeout=None,
params={
'client_id': '<application id>',
'client_secret': '<application secret key>',
'grant_type': 'fb_exchange_token',
'fb_exchange_token': '<access token>'
}
)
assert_equal(access_token, '<extended access token>')
assert not expires_at
def test_get_extended_access_token_no_expiry():
mock_request.return_value.status_code = 200
mock_request.return_value.content = 'access_token=<extended access token>'
access_token, expires_at = get_extended_access_token(
'<access token>',
'<application id>',
'<application secret key>'
)
mock_request.assert_called_with(
'GET',
'https://graph.facebook.com/oauth/access_token',
allow_redirects=True,
verify=True,
timeout=None,
params={
'client_id': '<application id>',
'client_secret': '<application secret key>',
'grant_type': 'fb_exchange_token',
'fb_exchange_token': '<access token>'
}
)
assert_equal(access_token, '<extended access token>')
assert expires_at is None
def test_get_extended_access_token_v23_plus():
mock_request.return_value.status_code = 200
mock_request.return_value.content = (
'{"access_token":"<extended access token>","token_type":"bearer"}')
access_token, expires_at = get_extended_access_token(
'<access token>',
'<application id>',
'<application secret key>',
api_version='2.3')
mock_request.assert_called_with(
'GET',
'https://graph.facebook.com/v2.3/oauth/access_token',
allow_redirects=True,
verify=True,
timeout=None,
params={
'client_id': '<application id>',
'client_secret': '<application secret key>',
'grant_type': 'fb_exchange_token',
'fb_exchange_token': '<access token>'
})
assert_equal(access_token, '<extended access token>')
assert not expires_at
def extend_access_token(saved_props, token, sublets_api_id,
sublets_secret_key):
log("Extending access token", Color.BOLD)
access_token, expires_at = facepy.get_extended_access_token(
token, sublets_api_id, sublets_secret_key)
new_token = access_token
unixtime = time.mktime(expires_at.timetuple())
print time.mktime(expires_at.timetuple())
saved_props['sublets_oauth_access_token'] = new_token
saved_props['access_token_expiration'] = unixtime
log("Token extended", Color.BOLD)
def extend_access_token(saved_props, token, sublets_api_id,
sublets_secret_key):
log("Extending access token", Color.BOLD)
access_token, expires_at = facepy.get_extended_access_token(
token,
sublets_api_id,
sublets_secret_key
)
new_token = access_token
unixtime = time.mktime(expires_at.timetuple())
print time.mktime(expires_at.timetuple())
saved_props['sublets_oauth_access_token'] = new_token
saved_props['access_token_expiration'] = unixtime
log("Token extended", Color.BOLD)
def validate(self, data):
req = facepy.SignedRequest(data['signed_request'],
settings.FACEBOOK_APP_SECRET_KEY,
settings.FACEBOOK_APP_ID)
# XXX handle facebook exceptions
# for example, the user can refuse to share their email address
graph = facepy.GraphAPI(req.user.oauth_token.token)
data = graph.get('me?fields=email,first_name,last_name,third_party_id')
extended_token = facepy.get_extended_access_token(
req.user.oauth_token.token,
settings.FACEBOOK_APP_ID, settings.FACEBOOK_APP_SECRET_KEY)
user = User.objects.get_or_create_facebook_user(data, extended_token)[0]
return {'user': user}
def test_get_extended_access_token_no_expiry():
mock_request.return_value.status_code = 200
mock_request.return_value.content = 'access_token=<extended access token>'
access_token, expires_at = get_extended_access_token(
'<access token>', '<application id>', '<application secret key>')
mock_request.assert_called_with(
'GET',
'https://graph.facebook.com/oauth/access_token',
allow_redirects=True,
verify=True,
timeout=None,
params={
'client_id': '<application id>',
'client_secret': '<application secret key>',
'grant_type': 'fb_exchange_token',
'fb_exchange_token': '<access token>'
})
assert_equal(access_token, '<extended access token>')
assert expires_at is None
def api_backend_login(request):
if not request.is_ajax():
return HttpResponse()
# only take this shortcut for admin users
if request.user.is_authenticated() and request.user.is_superuser:
logger.debug(
"Superuser already logged in: {0}".format(request.user.username))
return HttpResponse()
data = request.POST
logger.debug("Post data: {0}".format(data));
fbUid = data['fbUid']
fbName = data['name']
fbAccessToken = data['accessToken']
logger.debug("Logging in with facebook: {0} - {1}".format(fbName, fbUid))
fb_app_id = os.environ.get('FB_APP_ID', '')
fb_app_secret_key = os.environ.get('FB_APP_SECRET_KEY', '')
# get the accessToken, and verify with the app secret
# convert it into a long term token (use app id and app secret)
try:
fbLongAccessToken, expires_at = facepy.get_extended_access_token(
fbAccessToken, fb_app_id, fb_app_secret_key)
logger.debug(
"facebook access token valid: {0}, long token: {1}"
"".format(fbAccessToken, fbLongAccessToken))
except facepy.exceptions.OAuthError:
logger.debug("facebook access token failed: {0}".format(fbAccessToken))
reply = {"reply": "ERROR", "user": user.username}
return HttpResponse(
json.dumps(reply, sort_keys=True, separators=(',',':'), indent=4),
content_type='application/json'
)
if fbUid:
user = User.objects.filter(username=fbUid)
if user:
logger.debug("Logging in existing user: {0} - {1}".format(fbName, fbUid))
elif user is not None:
logger.debug("Logging in new user: {0} - {1}".format(fbName, fbUid))
user = User.objects.create_user(
username=fbUid,
first_name = fbName,
password='******')
user.save()
# we don't use password based authentication (dummy pw)
user = authenticate(username=fbUid, password='******')
if user is not None:
login(request, user)
fb_user = FacebookUser(
user_id=user,
fb_name = data.get('fbData[name]', 'fb_name'),
fb_first_name = data.get('fbData[first_name]', 'fb_first_name'),
fb_last_name = data.get('fbData[last_name]', 'fb_last_name'),
fb_email = data.get('fbData[email]', 'fb_email'),
)
fb_user.save()
user.email = fb_user.fb_email
user.save()
reply = {"reply": "OK", "user": user.username}
return HttpResponse(
json.dumps(reply, sort_keys=True, separators=(',',':'), indent=4),
content_type='application/json'
)
#!/usr/bin/env python3
# Extend user access token
import argparse
from facepy import get_extended_access_token
argParser = argparse.ArgumentParser()
argParser.add_argument('--appid', required=True)
argParser.add_argument('--appsecret', required=True)
argParser.add_argument('--token', required=True)
args = argParser.parse_args()
print(get_extended_access_token(args.token, args.appid, args.appsecret)[0])
def count_group_likes():
fb_api_access_token = props.token
fb_app_id = props.app_id
fb_secret_key = props.secret_key
# Counter object to do the counting for us
total_likes_counter = Counter()
top_liked_posts_counter = Counter()
top_liked_comments_counter = Counter()
total_posts_counter = Counter()
total_comments_counter = Counter()
most_discussed_counter = Counter()
group_id = props.group_id
num_of_items_to_return = props.num_of_items
# Put the number of weeks you want it to increment by each time
# smaller is better, but too small and you could hit your rate limit
# ... which is 600 calls per 600 seconds. Maybe apps get more
num_weeks = int("2")
# Convert to unix time
num_weeks_unix = num_weeks * 604800
start_date = props.start_date
datetime_start_date = datetime.datetime.fromtimestamp(start_date)
# Query strings for FQL
posts_query = \
"SELECT post_id, like_info, actor_id, created_time FROM stream" + \
" WHERE source_id=" + group_id + " AND created_time<"
person_query = "SELECT first_name, last_name FROM user WHERE uid="
# Authorize our API wrapper
graph = facepy.GraphAPI(fb_api_access_token)
# Code to programatically extend key
if extend_key:
access_token, expires_at = facepy.get_extended_access_token(
fb_api_access_token,
fb_app_id,
fb_secret_key
)
# This will print out new extended token and new expiration date
# Copy them and replace your token above with this one
print 'New token: ' + access_token
print 'New expiration date: ' + expires_at
log('Getting group posts', Color.BLUE)
# Send end time to current time and work backward
end_time = int(time.time())
# Or manually set end time
# end_time = 1392422400
log('Current date is: ' + datetime.datetime.fromtimestamp(
end_time).strftime('%Y-%m-%d'))
log('Incrementing by ' + str(num_weeks) + ' weeks at a time')
# List of thread objects
threads = []
# Threadsafe queue for the threads to dump their data in
final_queue = Queue()
log("Initializing threads...", Color.BLUE)
# While loop that creates the threads
# Instantiates each thread with calculated time, keeps decrementing to
# start
while end_time > start_date:
# New query
new_query = posts_query + str(
end_time) + " AND created_time>" + \
str(end_time - num_weeks_unix) + " LIMIT 600"
# Thread creation
t = RequestThread(final_queue, fb_api_access_token, new_query,
end_time, num_weeks_unix)
# Add it to our list
threads.append(t)
# Decrement the time
end_time -= num_weeks_unix
# Start the thread
t.start()
log("Joining threads...", Color.BLUE)
# Wait for all the threads to finish before counting everything up
for t in threads:
t.join()
log("Done, merging data...", Color.BLUE)
# Count up all the data by merging all the counters from each thread result
for stuff in list(final_queue.queue):
total_likes_counter += stuff['t']
top_liked_posts_counter += stuff['p']
top_liked_comments_counter += stuff['c']
total_posts_counter += stuff['tp']
total_comments_counter += stuff['tc']
most_discussed_counter += stuff['cc']
most_active_day_counter = total_posts_counter + total_comments_counter
# Returns key-value list of top <num_of_items_to_return> items
most_common_people = total_likes_counter.most_common(
num_of_items_to_return)
top_posts = top_liked_posts_counter.most_common(num_of_items_to_return)
top_comments = top_liked_comments_counter.most_common(
num_of_items_to_return)
total_posts = total_posts_counter.most_common(num_of_items_to_return)
total_comments = total_comments_counter.most_common(num_of_items_to_return)
most_active_days = most_active_day_counter.most_common(
num_of_items_to_return)
most_discussed = most_discussed_counter.most_common(num_of_items_to_return)
top_people_stats = []
# Iterate over top people and retrieve names from their ID's
# Use enumerate to keep track of indices for rank numbers
log('\nPeople Stats', Color.BOLD)
log("* = Weighted average calc'd from user's first post date")
for i, x in enumerate(most_common_people):
person = graph.fql(person_query + str(x[0]))["data"][0]
now = datetime.datetime.now()
join_date = datetime.datetime.fromtimestamp(appeared[x[0]])
diff1 = now - datetime_start_date
diff2 = now - join_date
avg = x[1] / (diff1.total_seconds() / 60 / 60 / 24 / 7)
weighted_avg = x[1] / (diff2.total_seconds() / 60 / 60 / 24 / 7)
top_people_stats.append({
"name": person['first_name'] + " " + person['last_name'],
"likes": x[1],
"avg": avg,
"augmented_avg": weighted_avg,
"first": int(
(join_date - datetime.datetime(1970, 1, 1)).total_seconds())
})
print '#' + str(i + 1) + '. ' + person['first_name'] + " " + person[
'last_name']
print '-- Likes: ' + str(x[1])
print '-- Weekly average: ' + str(avg)
print '-- Weekly average*: ' + str(weighted_avg)
print '-- First post: ' + join_date.strftime('%Y-%m-%d')
# Iterate over top posts and get info
log('\nTop posts!', Color.BOLD)
for x in top_posts:
post = graph.get(str(x[0]))
s = str(x[1]) + " - " + post['from']['name'] + " - " + post['type']
print s
if 'message' in post:
m = str(post['message'].encode('ascii', 'ignore')).replace('\n',
' ')
if len(m) > 70:
print '-- ' + m[0:70] + "..."
else:
print '-- ' + m
print '-- http://www.facebook.com/' + post['id']
# Iterate over top comments and get info
log('\nTop comments!', Color.BOLD)
for x in top_comments:
comment = graph.get(str(x[0]))
s = str(x[1]) + " - " + comment['from']['name']
print s
if 'message' in comment:
c = str(comment['message'].encode('ascii', 'ignore')).replace('\n',
' ')
if len(c) > 70:
print '-- ' + c[0:70] + "..."
else:
print '-- ' + c
print '-- http://www.facebook.com/' + comment['id']
# Iterate over total posts/comments and calculate info
log('\nMost active days (by number of posts and comments)', Color.BOLD)
for x in most_active_days:
d = datetime.datetime.fromtimestamp(float(x[0])).strftime('%m/%d/%Y')
print str(x[1]) + " - " + d
# Iterate over total posts and calculate info
log('\nMost active days (by number of posts)', Color.BOLD)
for x in total_posts:
d = datetime.datetime.fromtimestamp(float(x[0])).strftime('%m/%d/%Y')
print str(x[1]) + " - " + d
# Iterate over total comments and calculate info
log('\nMost active days (by number of comments)', Color.BOLD)
for x in total_comments:
d = datetime.datetime.fromtimestamp(float(x[0])).strftime('%m/%d/%Y')
print str(x[1]) + " - " + d
# Iterate over top posts and get info
log('\nMost discussed', Color.BOLD)
for x in most_discussed:
post = graph.get(str(x[0]))
s = str(x[1]) + " - " + post['from']['name'] + " - " + post['type']
print s
if 'message' in post:
m = str(post['message'].encode('ascii', 'ignore')).replace('\n',
' ')
if len(m) > 70:
print '-- ' + m[0:70] + "..."
else:
print '-- ' + m
print '-- http://www.facebook.com/' + post['id']
log('\nExporting...', Color.BLUE)
dataDict = json.dumps({"top_people_stats": top_people_stats,
"top_liked_posts_counter": top_liked_posts_counter,
"top_liked_comments_counter": top_liked_comments_counter,
"total_posts_counter": total_posts_counter,
"total_comments_counter": total_comments_counter,
"most_active_day_counter": most_active_day_counter,
"most_common_people": most_common_people,
"top_posts": top_posts,
"top_comments": top_comments,
"total_posts": total_posts,
"total_comments": total_comments,
"most_active_days": most_active_days})
exportData(dataDict)
def count_group_likes():
# Only necessary if you want to get an extended access token
# You'll have to make a facebook app and generate a token with it
# You'll also need to get the following two values from it
fb_app_id = "id_goes_here"
fb_secret_key = "key_goes_here"
# Counter object to do the counting for us
total_likes_counter = Counter()
top_liked_posts_counter = Counter()
top_liked_comments_counter = Counter()
total_posts_counter = Counter()
total_comments_counter = Counter()
most_discussed_counter = Counter()
group_id = "155607091223285" # Unique ID of the group to search.
# Put the number of weeks you want it to increment by each time
# smaller is better, but too small and you could hit your rate limit
# ... which is 600 calls per 600 seconds. Maybe apps get more
num_weeks = int("2")
# Convert to unix time
num_weeks_unix = num_weeks * 604800
# Start date, in unix time (our group was made 2/13/12) 1329091200
# You can use this to convert: http://goo.gl/4QMFbW
start_date = int("1329091200")
datetime_start_date = datetime.datetime.fromtimestamp(start_date)
# Query strings for FQL
posts_query = \
"SELECT post_id, like_info, actor_id, created_time FROM stream" + \
" WHERE source_id=" + group_id + " AND created_time<"
person_query = "SELECT first_name, middle_name, last_name FROM user WHERE uid="
# Authorize our API wrapper
graph = facepy.GraphAPI(fb_API_access_token)
# Code to programatically extend key
if extend_key:
access_token, expires_at = facepy.get_extended_access_token(
fb_API_access_token, fb_app_id, fb_secret_key)
# This will print out new extended token and new expiration date
# Copy them and replace your token above with this one
print 'New token: ' + access_token
print 'New expiration date: ' + expires_at
log('Getting group posts', Color.BLUE)
# Send end time to current time and work backward
end_time = int(time.time())
# Or manually set end time
# end_time = 1392422400
log('Current date is: ' +
datetime.datetime.fromtimestamp(end_time).strftime('%Y-%m-%d'))
log('Incrementing by ' + str(num_weeks) + ' weeks at a time')
# List of thread objects
threads = []
# Threadsafe queue for the threads to dump their data in
final_queue = Queue()
log("Initializing threads...", Color.BLUE)
# While loop that creates the threads
# Instantiates each thread with calculated time, keeps decrementing to
# start
while end_time > start_date:
# New query
new_query = posts_query + str(
end_time) + " AND created_time>" + \
str(end_time - num_weeks_unix) + " LIMIT 2000"
# Thread creation
t = RequestThread(final_queue, fb_API_access_token, new_query,
end_time, num_weeks_unix)
# Add it to our list
threads.append(t)
# Decrement the time
end_time -= num_weeks_unix
# Start the thread
t.start()
log("Joining threads...", Color.BLUE)
# Wait for all the threads to finish before counting everything up
for t in threads:
t.join()
log("Done, merging data...", Color.BLUE)
# Count up all the data by merging all the counters from each thread result
for stuff in list(final_queue.queue):
total_likes_counter += stuff['t']
top_liked_posts_counter += stuff['p']
top_liked_comments_counter += stuff['c']
total_posts_counter += stuff['tp']
total_comments_counter += stuff['tc']
most_discussed_counter += stuff['cc']
most_active_day_counter = total_posts_counter + total_comments_counter
# Returns key-value list of top <num_of_items_to_return> items
num_of_items_to_return = 2000
most_common_people = total_likes_counter.most_common(
num_of_items_to_return)
total_comments = total_comments_counter.most_common(num_of_items_to_return)
top_people_stats = []
# Iterate over top people and retrieve names from their ID's
# Use enumerate to keep track of indices for rank numbers
schema = [
"rank", "name", "likes", "likesPerWeek", "comments", "commentsPerWeek",
"likesPerComment", "posts", "firstPost"
]
standings_file = open('../likes.json', 'w')
standings_file.write("[\n")
for i, x in enumerate(most_common_people):
person = graph.fql(person_query + str(x[0]))["data"][0]
now = datetime.datetime.now()
join_date = datetime.datetime.fromtimestamp(appeared[x[0]])
diff1 = now - datetime_start_date
diff2 = now - join_date
avg = x[1] / (diff1.total_seconds() / 60 / 60 / 24 / 7)
weighted_avg = x[1] / (diff2.total_seconds() / 60 / 60 / 24 / 7)
comments_per_week = total_comments_counter[x[0]] / (
diff2.total_seconds() / 60 / 60 / 24 / 7)
top_people_stats.append({
"name":
person['first_name'] + " " + person['last_name'],
"likes":
x[1],
"avg":
avg,
"augmented_avg":
weighted_avg,
"first":
int((join_date - datetime.datetime(1970, 1, 1)).total_seconds())
})
fullName = ""
if person['middle_name'] is None:
fullName = person['first_name'] + " " + person['last_name']
elif (len(person['middle_name']) > 0):
fullName = person['first_name'] + " " + person[
'middle_name'] + " " + person['last_name']
else:
fullName = person['first_name'] + " " + person['last_name']
likesPerComment = 0
if total_comments_counter[x[0]] > 0:
likesPerComment = (1.0 * x[1]) / float(
total_comments_counter[x[0]])
rank = i + 1
dp = DataPoint(i + 1, fullName, x[1], weighted_avg,
total_comments_counter[x[0]], comments_per_week,
likesPerComment, total_posts_counter[x[0]],
join_date.strftime('%Y-%m-%d'))
try:
print str(dp).encode('utf8')
standings_file.write("{\n")
standings_file.write(str(dp).encode('utf8'))
standings_file.write("},\n")
except UnicodeEncodeError:
pass
standings_file.write("\n]")
standings_file.close()
def _genLL(self, token, appId, appSecret):
try:
return get_extended_access_token(token, appId, appSecret)
except Exception as e:
self.print(e)
def count_group_likes():
fb_api_access_token = props.token
fb_app_id = props.app_id
fb_secret_key = props.secret_key
# Counter object to do the counting for us
total_likes_counter = Counter()
top_liked_posts_counter = Counter()
top_liked_comments_counter = Counter()
total_posts_counter = Counter()
total_comments_counter = Counter()
most_discussed_counter = Counter()
group_id = props.group_id
num_of_items_to_return = props.num_of_items
# Put the number of weeks you want it to increment by each time
# smaller is better, but too small and you could hit your rate limit
# ... which is 600 calls per 600 seconds. Maybe apps get more
num_weeks = int("2")
# Convert to unix time
num_weeks_unix = num_weeks * 604800
start_date = props.start_date
datetime_start_date = datetime.datetime.fromtimestamp(start_date)
# Query strings for FQL
posts_query = \
"SELECT post_id, like_info, actor_id, created_time FROM stream" + \
" WHERE source_id=" + group_id + " AND created_time<"
person_query = "SELECT first_name, last_name FROM user WHERE uid="
# Authorize our API wrapper
graph = facepy.GraphAPI(fb_api_access_token)
# Code to programatically extend key
if extend_key:
access_token, expires_at = facepy.get_extended_access_token(
fb_api_access_token, fb_app_id, fb_secret_key)
# This will print out new extended token and new expiration date
# Copy them and replace your token above with this one
print 'New token: ' + access_token
print 'New expiration date: ' + expires_at
log('Getting group posts', Color.BLUE)
# Send end time to current time and work backward
end_time = int(time.time())
# Or manually set end time
# end_time = 1392422400
log('Current date is: ' +
datetime.datetime.fromtimestamp(end_time).strftime('%Y-%m-%d'))
log('Incrementing by ' + str(num_weeks) + ' weeks at a time')
# List of thread objects
threads = []
# Threadsafe queue for the threads to dump their data in
final_queue = Queue()
log("Initializing threads...", Color.BLUE)
# While loop that creates the threads
# Instantiates each thread with calculated time, keeps decrementing to
# start
while end_time > start_date:
# New query
new_query = posts_query + str(
end_time) + " AND created_time>" + \
str(end_time - num_weeks_unix) + " LIMIT 600"
# Thread creation
t = RequestThread(final_queue, fb_api_access_token, new_query,
end_time, num_weeks_unix)
# Add it to our list
threads.append(t)
# Decrement the time
end_time -= num_weeks_unix
# Start the thread
t.start()
log("Joining threads...", Color.BLUE)
# Wait for all the threads to finish before counting everything up
for t in threads:
t.join()
log("Done, merging data...", Color.BLUE)
# Count up all the data by merging all the counters from each thread result
for stuff in list(final_queue.queue):
total_likes_counter += stuff['t']
top_liked_posts_counter += stuff['p']
top_liked_comments_counter += stuff['c']
total_posts_counter += stuff['tp']
total_comments_counter += stuff['tc']
most_discussed_counter += stuff['cc']
most_active_day_counter = total_posts_counter + total_comments_counter
# Returns key-value list of top <num_of_items_to_return> items
most_common_people = total_likes_counter.most_common(
num_of_items_to_return)
top_posts = top_liked_posts_counter.most_common(num_of_items_to_return)
top_comments = top_liked_comments_counter.most_common(
num_of_items_to_return)
total_posts = total_posts_counter.most_common(num_of_items_to_return)
total_comments = total_comments_counter.most_common(num_of_items_to_return)
most_active_days = most_active_day_counter.most_common(
num_of_items_to_return)
most_discussed = most_discussed_counter.most_common(num_of_items_to_return)
top_people_stats = []
# Iterate over top people and retrieve names from their ID's
# Use enumerate to keep track of indices for rank numbers
log('\nPeople Stats', Color.BOLD)
log("* = Weighted average calc'd from user's first post date")
for i, x in enumerate(most_common_people):
person = graph.fql(person_query + str(x[0]))["data"][0]
now = datetime.datetime.now()
join_date = datetime.datetime.fromtimestamp(appeared[x[0]])
diff1 = now - datetime_start_date
diff2 = now - join_date
avg = x[1] / (diff1.total_seconds() / 60 / 60 / 24 / 7)
weighted_avg = x[1] / (diff2.total_seconds() / 60 / 60 / 24 / 7)
top_people_stats.append({
"name":
person['first_name'] + " " + person['last_name'],
"likes":
x[1],
"avg":
avg,
"augmented_avg":
weighted_avg,
"first":
int((join_date - datetime.datetime(1970, 1, 1)).total_seconds())
})
print '#' + str(
i + 1) + '. ' + person['first_name'] + " " + person['last_name']
print '-- Likes: ' + str(x[1])
print '-- Weekly average: ' + str(avg)
print '-- Weekly average*: ' + str(weighted_avg)
print '-- First post: ' + join_date.strftime('%Y-%m-%d')
# Iterate over top posts and get info
log('\nTop posts!', Color.BOLD)
for x in top_posts:
post = graph.get(str(x[0]))
s = str(x[1]) + " - " + post['from']['name'] + " - " + post['type']
print s
if 'message' in post:
m = str(post['message'].encode('ascii',
'ignore')).replace('\n', ' ')
if len(m) > 70:
print '-- ' + m[0:70] + "..."
else:
print '-- ' + m
print '-- http://www.facebook.com/' + post['id']
# Iterate over top comments and get info
log('\nTop comments!', Color.BOLD)
for x in top_comments:
comment = graph.get(str(x[0]))
s = str(x[1]) + " - " + comment['from']['name']
print s
if 'message' in comment:
c = str(comment['message'].encode('ascii',
'ignore')).replace('\n', ' ')
if len(c) > 70:
print '-- ' + c[0:70] + "..."
else:
print '-- ' + c
print '-- http://www.facebook.com/' + comment['id']
# Iterate over total posts/comments and calculate info
log('\nMost active days (by number of posts and comments)', Color.BOLD)
for x in most_active_days:
d = datetime.datetime.fromtimestamp(float(x[0])).strftime('%m/%d/%Y')
print str(x[1]) + " - " + d
# Iterate over total posts and calculate info
log('\nMost active days (by number of posts)', Color.BOLD)
for x in total_posts:
d = datetime.datetime.fromtimestamp(float(x[0])).strftime('%m/%d/%Y')
print str(x[1]) + " - " + d
# Iterate over total comments and calculate info
log('\nMost active days (by number of comments)', Color.BOLD)
for x in total_comments:
d = datetime.datetime.fromtimestamp(float(x[0])).strftime('%m/%d/%Y')
print str(x[1]) + " - " + d
# Iterate over top posts and get info
log('\nMost discussed', Color.BOLD)
for x in most_discussed:
post = graph.get(str(x[0]))
s = str(x[1]) + " - " + post['from']['name'] + " - " + post['type']
print s
if 'message' in post:
m = str(post['message'].encode('ascii',
'ignore')).replace('\n', ' ')
if len(m) > 70:
print '-- ' + m[0:70] + "..."
else:
print '-- ' + m
print '-- http://www.facebook.com/' + post['id']
log('\nExporting...', Color.BLUE)
dataDict = json.dumps({
"top_people_stats": top_people_stats,
"top_liked_posts_counter": top_liked_posts_counter,
"top_liked_comments_counter": top_liked_comments_counter,
"total_posts_counter": total_posts_counter,
"total_comments_counter": total_comments_counter,
"most_active_day_counter": most_active_day_counter,
"most_common_people": most_common_people,
"top_posts": top_posts,
"top_comments": top_comments,
"total_posts": total_posts,
"total_comments": total_comments,
"most_active_days": most_active_days
})
exportData(dataDict)
def count_group_likes():
# Only necessary if you want to get an extended access token
# You'll have to make a facebook app and generate a token with it
# You'll also need to get the following two values from it
fb_app_id = "id_goes_here"
fb_secret_key = "key_goes_here"
# Counter object to do the counting for us
total_likes_counter = Counter()
top_liked_posts_counter = Counter()
top_liked_comments_counter = Counter()
total_posts_counter = Counter()
total_comments_counter = Counter()
most_discussed_counter = Counter()
group_id = "155607091223285" # Unique ID of the group to search.
# Put the number of weeks you want it to increment by each time
# smaller is better, but too small and you could hit your rate limit
# ... which is 600 calls per 600 seconds. Maybe apps get more
num_weeks = int("2")
# Convert to unix time
num_weeks_unix = num_weeks * 604800
# Start date, in unix time (our group was made 2/13/12) 1329091200
# You can use this to convert: http://goo.gl/4QMFbW
start_date = int("1329091200")
datetime_start_date = datetime.datetime.fromtimestamp(start_date)
# Query strings for FQL
posts_query = \
"SELECT post_id, like_info, actor_id, created_time FROM stream" + \
" WHERE source_id=" + group_id + " AND created_time<"
person_query = "SELECT first_name, middle_name, last_name FROM user WHERE uid="
# Authorize our API wrapper
graph = facepy.GraphAPI(fb_API_access_token)
# Code to programatically extend key
if extend_key:
access_token, expires_at = facepy.get_extended_access_token(
fb_API_access_token,
fb_app_id,
fb_secret_key
)
# This will print out new extended token and new expiration date
# Copy them and replace your token above with this one
print 'New token: ' + access_token
print 'New expiration date: ' + expires_at
log('Getting group posts', Color.BLUE)
# Send end time to current time and work backward
end_time = int(time.time())
# Or manually set end time
# end_time = 1392422400
log('Current date is: ' + datetime.datetime.fromtimestamp(
end_time).strftime('%Y-%m-%d'))
log('Incrementing by ' + str(num_weeks) + ' weeks at a time')
# List of thread objects
threads = []
# Threadsafe queue for the threads to dump their data in
final_queue = Queue()
log("Initializing threads...", Color.BLUE)
# While loop that creates the threads
# Instantiates each thread with calculated time, keeps decrementing to
# start
while end_time > start_date:
# New query
new_query = posts_query + str(
end_time) + " AND created_time>" + \
str(end_time - num_weeks_unix) + " LIMIT 2000"
# Thread creation
t = RequestThread(final_queue, fb_API_access_token, new_query,
end_time, num_weeks_unix)
# Add it to our list
threads.append(t)
# Decrement the time
end_time -= num_weeks_unix
# Start the thread
t.start()
log("Joining threads...", Color.BLUE)
# Wait for all the threads to finish before counting everything up
for t in threads:
t.join()
log("Done, merging data...", Color.BLUE)
# Count up all the data by merging all the counters from each thread result
for stuff in list(final_queue.queue):
total_likes_counter += stuff['t']
top_liked_posts_counter += stuff['p']
top_liked_comments_counter += stuff['c']
total_posts_counter += stuff['tp']
total_comments_counter += stuff['tc']
most_discussed_counter += stuff['cc']
most_active_day_counter = total_posts_counter + total_comments_counter
# Returns key-value list of top <num_of_items_to_return> items
num_of_items_to_return = 2000
most_common_people = total_likes_counter.most_common(num_of_items_to_return)
total_comments = total_comments_counter.most_common(num_of_items_to_return)
top_people_stats = []
# Iterate over top people and retrieve names from their ID's
# Use enumerate to keep track of indices for rank numbers
schema = ["rank","name","likes","likesPerWeek","comments","commentsPerWeek","likesPerComment","posts","firstPost"]
standings_file = open('../likes.json', 'w')
standings_file.write("[\n")
for i, x in enumerate(most_common_people):
person = graph.fql(person_query + str(x[0]))["data"][0]
now = datetime.datetime.now()
join_date = datetime.datetime.fromtimestamp(appeared[x[0]])
diff1 = now - datetime_start_date
diff2 = now - join_date
avg = x[1] / (diff1.total_seconds() / 60 / 60 / 24 / 7)
weighted_avg = x[1] / (diff2.total_seconds() / 60 / 60 / 24 / 7)
comments_per_week = total_comments_counter[x[0]] / (diff2.total_seconds() / 60 / 60 / 24 / 7)
top_people_stats.append({
"name": person['first_name'] + " " + person['last_name'],
"likes": x[1],
"avg": avg,
"augmented_avg": weighted_avg,
"first": int(
(join_date - datetime.datetime(1970, 1, 1)).total_seconds())
})
fullName = ""
if person['middle_name'] is None:
fullName = person['first_name'] + " " + person['last_name']
elif (len(person['middle_name']) > 0):
fullName = person['first_name'] + " " + person['middle_name'] + " " + person['last_name']
else:
fullName = person['first_name'] + " " + person['last_name']
likesPerComment = 0
if total_comments_counter[x[0]] > 0:
likesPerComment = (1.0*x[1])/float(total_comments_counter[x[0]])
rank = i+1
dp = DataPoint(i+1,fullName,x[1],weighted_avg,total_comments_counter[x[0]],comments_per_week,likesPerComment,total_posts_counter[x[0]],join_date.strftime('%Y-%m-%d'))
try:
print str(dp).encode('utf8')
standings_file.write("{\n")
standings_file.write(str(dp).encode('utf8'))
standings_file.write("},\n")
except UnicodeEncodeError:
pass
standings_file.write("\n]")
standings_file.close()
def post(self, request, *args, **kwargs):
body = json.loads(request.body)
api_type = body.get('type', None)
email = None
# expect social media outlet (facebook, linkedin, etc) and access token
if (api_type == 'facebook'):
# TODO for facebook, get extended access token and save that instead
access_token, expires_at = get_extended_access_token(body.get('access_token', None), settings.FACEBOOK_APP_ID, settings.FACEBOOK_API_SECRET)
graph = GraphAPI(access_token)
api_user = graph.get('/me')
# TODO check for existing user profile
try:
user = User.objects.get(email = api_user.get('email', None))
is_new = False
except User.DoesNotExist:
is_new = True
print 'new user {0}'.format(api_user.get('email'))
arg_user = {
'email': api_user.get('email'),
'username': api_user.get('email'),
'first_name': api_user.get('first_name'),
'last_name': api_user.get('last_name'),
'password': None
}
#user = User.objects.create_user(api_user.get('email'), api_user.get('email'), None)
user = User.objects.create_user(**arg_user)
user.first_name = api_user.get('first_name')
user.last_name = api_user.get('last_name')
user.save()
profile = user.profile
profile.avatar_url = 'http://graph.facebook.com/{0}/picture'.format(api_user.get('id'))
profile.blurb = api_user.get('quotes', None)
profile.save()
# TODO generate access token or get existing
arg_access_token = {
'access_token': access_token, # TODO don't use facebook's access token
'expires': time.mktime(expires_at.timetuple()) # TODO don't use facebook's expiry
}
try:
user_access_token = UserAccessToken.objects.get(user = user)
is_new_access_token = False
except UserAccessToken.DoesNotExist:
user_access_token = UserAccessToken.objects.create(user = user, **arg_access_token)
is_new_access_token = True
# TODO update access token
print 'user {0} exists'.format(user.email)
else:
return HttpResponse('{}', mimetype="application/json")
response = {
'access_token': user_access_token.access_token,
'expires': user_access_token.expires,
'user': {
'is_new': is_new,
'id': user.id,
'first_name': user.first_name,
'last_name': user.last_name,
'avatar_url': profile.avatar_url,
'blurb': profile.blurb
}
}
return HttpResponse(json.dumps(response), mimetype="application/json")
