def build_graph_view(request, graph):
if graph:
try:
graph.is_authenticated()
except:
update_connection(request,graph)
user = FacebookUserConverter(graph)
friends = user.get_friends()
friend_requests = [
u'me/mutualfriends/{0}'.format(friend['id'])
for friend in friends
]
mutual_friends = []
batch_size = 50
batches = defaultdict(list)
for i,friend_request in enumerate(friend_requests):
batch_request = {
'method': 'GET','relative_url':friend_request
}
batches[i/batch_size].append(batch_request)
counter = 0
for batch in batches.values():
batch = json.dumps(batch)
responses = graph.request(
"", post_data = {'batch':batch}, fields='id'
)
mutual_friends += responses
print counter, 'success'
counter += 1
print len(mutual_friends)
json_data = process_fb_response(friends, mutual_friends, graph)
else:
return HttpResponse('Error')
return HttpResponse(json_data, mimetype='text/javascript')
def connect_user(request, access_token=None, facebook_graph=None):
'''
Given a request either
- (if authenticated) connect the user
- login
- register
'''
user = None
graph = facebook_graph or get_facebook_graph(request, access_token)
facebook = FacebookUserConverter(graph)
assert facebook.is_authenticated()
facebook_data = facebook.facebook_profile_data()
force_registration = request.REQUEST.get('force_registration') or request.REQUEST.get('force_registration_hard')
logger.debug('force registration is set to %s', force_registration)
if request.user.is_authenticated() and not force_registration:
action = CONNECT_ACTIONS.CONNECT
user = _connect_user(request, facebook)
else:
email = facebook_data.get('email', False)
email_verified = facebook_data.get('verified', False)
kwargs = {}
if email and email_verified:
kwargs = {'facebook_email': email}
authenticated_user = authenticate(facebook_id=facebook_data['id'], **kwargs)
if authenticated_user and not force_registration:
action = CONNECT_ACTIONS.LOGIN
## Has the user registered without Facebook, using the verified FB email address?
# It is after all quite common to use email addresses for usernames
if not authenticated_user.get_profile().facebook_id:
update = True
else:
update = getattr(authenticated_user, 'fb_update_required', False)
user = _login_user(request, facebook, authenticated_user, update=update)
else:
action = CONNECT_ACTIONS.REGISTER
user = _register_user(request, facebook)
#store likes and friends if configured
sid = transaction.savepoint()
try:
if facebook_settings.FACEBOOK_STORE_LIKES:
likes = facebook.get_likes()
facebook.store_likes(user, likes)
if facebook_settings.FACEBOOK_STORE_FRIENDS:
friends = facebook.get_friends()
facebook.store_friends(user, friends)
transaction.savepoint_commit(sid)
except IntegrityError, e:
logger.warn(u'Integrity error encountered during registration, probably a double submission %s' % e,
exc_info=sys.exc_info(), extra={
'request': request,
'data': {
'body': unicode(e),
}
})
transaction.savepoint_rollback(sid)
def test_open_facebook(request):
from django_facebook.api import FacebookUserConverter
fb = get_persistent_graph(request)
instace = FacebookUserConverter(fb)
# Get Friends
return HttpResponse(instace.get_friends())
def test_open_facebook(request):
from django_facebook.api import FacebookUserConverter
fb = get_persistent_graph(request)
instace = FacebookUserConverter(fb)
#Get Friends
return HttpResponse(instace.get_friends())
def retrieve_friends(request, field='uid'):
try:
open_graph = get_persistent_graph(request)
converter = FacebookUserConverter(open_graph)
friends = converter.get_friends()
friends_data = [u[field] for u in friends]
return friends_data
except Exception as e:
return []
print e
def retrieve_friends_dict(request):
try:
open_graph = get_persistent_graph(request)
converter = FacebookUserConverter(open_graph)
friends = converter.get_friends()
friends_data = {u['name'].strip().upper(): u['uid'] for u in friends}
return friends_data
except Exception as e:
return {}
print e
def get_queryset(self):
if not self.request.user.is_authenticated():
return UserData.objects.none()
try:
graph = require_facebook_graph(self.request)
except:
logout(self.request)
return UserData.objects.none()
my_info = graph.get('me')
converter = FacebookUserConverter(graph)
my_friends = converter.get_friends()
my_friends_facebook_id = []
for friend in my_friends:
if not friend["id"]:
continue
else:
my_friends_facebook_id.append(friend["id"])
users = UserData.objects.all().filter(facebook_id__in = my_friends_facebook_id)
return users
def connect_user(request, access_token=None, facebook_graph=None):
'''
Given a request either
- (if authenticated) connect the user
- login
- register
'''
user = None
graph = facebook_graph or get_facebook_graph(request, access_token)
facebook = FacebookUserConverter(graph)
assert facebook.is_authenticated()
facebook_data = facebook.facebook_profile_data()
force_registration = request.REQUEST.get('force_registration') or\
request.REQUEST.get('force_registration_hard')
logger.debug('force registration is set to %s', force_registration)
if request.user.is_authenticated() and not force_registration:
action = CONNECT_ACTIONS.CONNECT
user = _connect_user(request, facebook)
else:
email = facebook_data.get('email', False)
email_verified = facebook_data.get('verified', False)
kwargs = {}
if email and email_verified:
kwargs = {'facebook_email': email}
auth_user = authenticate(facebook_id=facebook_data['id'], **kwargs)
if auth_user and not force_registration:
action = CONNECT_ACTIONS.LOGIN
# Has the user registered without Facebook, using the verified FB
# email address?
# It is after all quite common to use email addresses for usernames
if not auth_user.get_profile().facebook_id:
update = True
else:
update = getattr(auth_user, 'fb_update_required', False)
user = _login_user(request, facebook, auth_user, update=update)
else:
action = CONNECT_ACTIONS.REGISTER
user = _register_user(request, facebook)
#store likes and friends if configured
sid = transaction.savepoint()
try:
if facebook_settings.FACEBOOK_STORE_LIKES:
likes = facebook.get_likes()
facebook.store_likes(user, likes)
if facebook_settings.FACEBOOK_STORE_FRIENDS:
friends = facebook.get_friends()
facebook.store_friends(user, friends)
transaction.savepoint_commit(sid)
except IntegrityError, e:
logger.warn(u'Integrity error encountered during registration, '
'probably a double submission %s' % e,
exc_info=sys.exc_info(),
extra={
'request': request,
'data': {
'body': unicode(e),
}
})
transaction.savepoint_rollback(sid)
def index(request):
if not request.user.is_authenticated():
return redirect("signup")
# return HttpResponse("damnnn doug")
context_instance = RequestContext(request)
User = get_user_model()
new_user_data = UserData.objects.all().filter(local_django_id = request.user.id)
# FacebookAuthorization.extend_access_token(access_token)
try:
graph = require_facebook_graph(request)
except:
logout(request)
# return HttpResponse("omg")
return redirect("signup")
my_info = graph.get('me')
if not new_user_data:
new_user = UserData()
new_user.local_django_id = request.user.id
new_user.facebook_id = my_info['id']
new_user.facebook_name = my_info['name']
new_user.save()
my_full_name = my_info['name'].split(" ")
my_first_name = my_full_name[0]
if (request.method == 'POST') and 'submit_party' in request.POST:
party_form = PartyForm(request.POST)
if party_form.is_valid():
new_party_info = party_form.save(commit = False) #if commit = false, only model info will be created , not saved
new_party_info.location_lat = request.POST['lat']
new_party_info.location_lng = request.POST['lng']
new_party_info.save()
new_user_in_party = UserInParty()
new_user_in_party.user = request.user
new_user_in_party.invited_by = request.user
new_user_in_party.invitation_accepted = 1
new_user_in_party.party = new_party_info
new_user_in_party.save()
return party_details(request, new_party_info.id)
else:
return HttpResponse(party_form.errors)
print (party_form.errors)
else:
party_form = PartyForm()
invitation_form = PartyInvitationForm()
party_info = []
#retrieve info from facebook
# graph = OpenFacebook(access_token)
converter = FacebookUserConverter(graph)
my_friends = converter.get_friends()
# my_friends = User.objects.all()
my_party = UserInParty.objects.all().filter(user = request.user, invitation_accepted = 1)
for friend_party_pair in my_party:
party_info.append(friend_party_pair.party)
party_num = len(party_info)
party_invitations = []
party_invitations = UserInParty.objects.all().filter(user = request.user, invitation_accepted = 0)
invitation_num = len(party_invitations)
food_newsfeed = Food.objects.none()
friends_in_party_newsfeed = UserInParty.objects.none()
# Update the news feed, take the top 5 most recent
for party in party_info:
party_food_newsfeed = Food.objects.all().filter(belong_to_party = party).order_by('-date_added')
food_newsfeed = food_newsfeed | party_food_newsfeed
party_friends_in_party_newsfeed = UserInParty.objects.all().filter(party = party, invitation_accepted = 1).order_by('-date_accepted')
friends_in_party_newsfeed = friends_in_party_newsfeed | party_friends_in_party_newsfeed
food_newsfeed = food_newsfeed[:5]
friends_in_party_newsfeed = friends_in_party_newsfeed[:5]
food_newsfeed_num = len(food_newsfeed)
members_newsfeed_num = len(friends_in_party_newsfeed)
#update food to bring, code to be updated
all_top_rated_food = TopRatedFood.objects.all()
top_rated_food_ids = []
for topfood in all_top_rated_food:
top_rated_food_ids.append(topfood.top_rated_food_id)
food_to_bring = Food.objects.all().filter(id__in = top_rated_food_ids, brought_by = request.user)
context = {"party_form": party_form, "party_info": party_info, "party_invitations": party_invitations,
"invitation_num": invitation_num, "party_num": party_num, "food_newsfeed": food_newsfeed,
"friends_in_party_newsfeed": friends_in_party_newsfeed, "food_newsfeed_num": food_newsfeed_num,
"members_newsfeed_num": members_newsfeed_num , "food_to_bring": food_to_bring, "food_to_bring_num": len(food_to_bring)
, "my_info": my_info, "my_friends":my_friends, "my_first_name":my_first_name}
return render(request, 'foll/intro.html', context, context_instance)
