def _wrapped_view(request, *args, **kwargs):
if canvas:
oauth_url, redirect_uri = generate_oauth_url(
scope_list, extra_params=extra_params)
else:
oauth_url, redirect_uri = get_oauth_url(
request, scope_list, extra_params=extra_params)
try:
# call get persistent graph and convert the
# token with correct redirect uri
get_persistent_graph(request, redirect_uri=redirect_uri)
return view_func(request, *args, **kwargs)
except open_facebook_exceptions.OpenFacebookException, e:
if test_permissions(request, scope_list, redirect_uri):
# an error if we already have permissions
# shouldn't have been caught
# raise to prevent bugs with error mapping to cause issues
raise
else:
logger.info(
u'requesting access with redirect uri: %s, error was %s',
redirect_uri, e)
response = response_redirect(oauth_url, canvas=canvas)
return response
def article(request):
if request.GET.__contains__("title") and request.GET.__contains__("price"):
form = ArticleForm(request.GET)
if form.is_valid():
article = form.save(commit=False)
article.owner = request.user
article.save()
# Publish on wall user
fb = get_persistent_graph(request)
message = article.get_wall_message()
fb.set("me/feed", message=message)
messages.info(request, "Publicar en tu muro esta Compra")
return HttpResponseRedirect("/mvp/article/%s" % article.pk)
if request.method == "POST":
form = ArticleForm(request.POST)
if form.is_valid():
article = form.save(commit=False)
article.owner = request.user
article.save()
# Publish on wall user
fb = get_persistent_graph(request)
message = article.get_wall_message()
fb.set("me/feed", message=message)
messages.info(request, "Publicar en tu muro esta Compra")
return HttpResponseRedirect("/mvp/article/%s" % article.pk)
else:
form = ArticleForm()
return render_to_response("mvp/article.html", {"form": form}, context_instance=RequestContext(request))
def article(request):
if request.GET.__contains__('title') and request.GET.__contains__('price'):
form = ArticleForm(request.GET)
if form.is_valid():
article = form.save(commit=False)
article.owner = request.user
article.save()
#Publish on wall user
fb = get_persistent_graph(request)
message = article.get_wall_message()
fb.set('me/feed', message=message)
messages.info(request, 'Publicar en tu muro esta Compra')
return HttpResponseRedirect('/mvp/article/%s' % article.pk)
if request.method == 'POST':
form = ArticleForm(request.POST)
if form.is_valid():
article = form.save(commit=False)
article.owner = request.user
article.save()
#Publish on wall user
fb = get_persistent_graph(request)
message = article.get_wall_message()
fb.set('me/feed', message=message)
messages.info(request, 'Publicar en tu muro esta Compra')
return HttpResponseRedirect('/mvp/article/%s' % article.pk)
else:
form = ArticleForm()
return render_to_response('mvp/article.html', {'form': form},
context_instance=RequestContext(request))
def _wrapped_view(request, *args, **kwargs):
oauth_url, current_uri, redirect_uri = get_oauth_url(
request, scope_list,
extra_params=extra_params)
try:
# call get persistent graph and convert the
# token with correct redirect uri
get_persistent_graph(request, redirect_uri=current_uri)
#Note we're not requiring a persistent graph here
#You should require a persistent graph in the view when you start using this
return view_func(request, *args, **kwargs)
except open_facebook_exceptions.OpenFacebookException, e:
permission_granted = test_permissions(
request, scope_list, current_uri)
if permission_granted:
# an error if we already have permissions
# shouldn't have been caught
# raise to prevent bugs with error mapping to cause issues
raise
else:
logger.info(
u'requesting access with redirect uri: %s, error was %s',
redirect_uri, e)
response = response_redirect(oauth_url, canvas=canvas)
return response
def _wrapped_view(request, *args, **kwargs):
oauth_url, redirect_uri = get_oauth_url(request,
scope_list,
extra_params=extra_params)
try:
# call get persistent graph and convert the
# token with correct redirect uri
get_persistent_graph(request, redirect_uri=redirect_uri)
#Note we're not requiring a persistent graph here
#You should require a persistent graph in the url when you start using this
return view_func(request, *args, **kwargs)
except open_facebook_exceptions.OpenFacebookException, e:
permission_granted = test_permissions(request, scope_list,
redirect_uri)
if permission_granted:
# an error if we already have permissions
# shouldn't have been caught
# raise to prevent bugs with error mapping to cause issues
raise
else:
logger.info(
u'requesting access with redirect uri: %s, error was %s',
redirect_uri, e)
response = response_redirect(oauth_url, canvas=canvas)
return response
def _wrapped_view(request, *args, **kwargs):
oauth_url, redirect_uri = get_oauth_url(request, scope_list, extra_params=extra_params)
try:
#call get persistent graph and convert the token with correct redirect uri
get_persistent_graph(request, redirect_uri=redirect_uri)
return view_func(request, *args, **kwargs)
except open_facebook_exceptions.OpenFacebookException, e:
if test_permissions(request, scope_list, redirect_uri):
#an error if we already have permissions shouldn't have been caught
#raise to prevent bugs with error mapping to cause issues
raise
else:
logger.info('requesting access with redirect uri: %s', redirect_uri)
response = HttpResponseRedirect(oauth_url)
return response
def test_permissions(request, scope_list, redirect_uri=None):
'''
Call Facebook me/permissions to see if we are allowed to do this
'''
from django_facebook.api import get_persistent_graph
from open_facebook import exceptions as facebook_exceptions
fb = get_persistent_graph(request, redirect_uri=redirect_uri)
permissions_dict = {}
if fb:
try:
permissions_response = fb.get('me/permissions')
permissions = permissions_response['data'][0]
except facebook_exceptions.OAuthException:
# this happens when someone revokes their permissions
# while the session is still stored
permissions = {}
permissions_dict = dict([(k, bool(int(v)))
for k, v in permissions.items()
if v == '1' or v == 1])
# see if we have all permissions
scope_allowed = True
for permission in scope_list:
if permission not in permissions_dict:
scope_allowed = False
# raise if this happens after a redirect though
if not scope_allowed and request.GET.get('attempt'):
raise(ValueError,
'Somehow facebook is not giving us the permissions needed, ' \
'lets break instead of endless redirects. Fb was %s and ' \
'permissions %s' % (fb, permissions_dict))
return scope_allowed
def authenticate(self, fn, request, *args, **kwargs):
'''
Authenticate the user
There are three options
a.) We have permissions, proceed with the view
b.) We tried getting permissions and failed, abort...
c.) We are about to ask for permissions
'''
redirect_uri = self.get_redirect_uri(request)
oauth_url = get_oauth_url(
self.scope_list, redirect_uri, extra_params=self.extra_params)
graph = get_persistent_graph(request, redirect_uri=redirect_uri)
# See if we have all permissions
permissions_granted = has_permissions(graph, self.scope_list)
if permissions_granted:
response = self.execute_view(
fn, request, graph=graph, *args, **kwargs)
elif request.REQUEST.get('attempt') == '1':
# Doing a redirect could end up causing infinite redirects
# If Facebook is somehow not giving permissions
# Time to show an error page
response = self.authentication_failed(fn, request, *args, **kwargs)
else:
response = self.oauth_redirect(oauth_url, redirect_uri)
return response
def remove_og_share(request):
graph = get_persistent_graph(request)
og_share_id = request.POST.get('og_share_id')
if og_share_id:
shares = OpenGraphShare.objects.filter(id=og_share_id)
for share in shares:
share.remove(graph)
def home(request):
graph = get_persistent_graph(request)
#me = graph.permissions()
#me = graph.fql("SELECT friends_about_me,friends_location,friends_hometown FROM permissions WHERE uid = me()")
#me = graph.fql("SELECT uid, name,current_address,current_location,relationship_status FROM user WHERE uid = me()")
me = graph.fql("SELECT current_location,pic_square FROM user WHERE uid IN (SELECT uid2 FROM friend WHERE uid1 = me())")
#me = graph.fql('SELECT name FROM user WHERE uid = me()')
#me1 = graph.fql("SELECT uid, name, pic_square FROM user WHERE uid = me() OR uid IN (SELECT uid2 FROM friend WHERE uid1 = me())")
g = list()
for li in me:
s = li.get('current_location')
if s is not None:
t = list()
t.append(s.get('city').encode('ascii','ignore'))
t.append(s.get('latitude'))
t.append(s.get('longitude'))
#t.append(s.get('country'))
#t.append(s.get('state'))
s1 = li.get('pic_square')
if s1 is not None:
t.append(s1.encode('ascii','ignore'))
g.append(t)
g = json.dumps(g)
return render(request, 'hellodjango/templates/map.html', {'me':me,'locations':g})
def test_permissions(request, scope_list, redirect_uri=None):
'''
Call Facebook me/permissions to see if we are allowed to do this
'''
from django_facebook.api import get_persistent_graph
from open_facebook import exceptions as facebook_exceptions
fb = get_persistent_graph(request, redirect_uri=redirect_uri)
permissions_dict = {}
if fb:
try:
permissions_response = fb.get('me/permissions')
permissions = permissions_response['data'][0]
except facebook_exceptions.OAuthException:
# this happens when someone revokes their permissions
# while the session is still stored
permissions = {}
permissions_dict = dict([(k, bool(int(v)))
for k, v in permissions.items()
if v == '1' or v == 1])
# see if we have all permissions
scope_allowed = True
for permission in scope_list:
if permission not in permissions_dict:
scope_allowed = False
# raise if this happens after a redirect though
if not scope_allowed and request.GET.get('attempt'):
raise ValueError(
'Somehow facebook is not giving us the permissions needed, ' \
'lets break instead of endless redirects. Fb was %s and ' \
'permissions %s' % (fb, permissions_dict))
return scope_allowed
def test_persistent_graph(self):
from django.test import RequestFactory
from django.contrib.auth.models import AnonymousUser
request = RequestFactory()
request.session = {}
request.user = AnonymousUser()
graph = get_persistent_graph(request, access_token='short_username')
def wall_post(request):
fb = get_persistent_graph(request)
message = request.POST.get('message')
if message:
fb.set('me/feed', message=message)
messages.info(request, 'Posted the message to your wall')
return next_redirect(request)
def test_permissions(request, scope_list, redirect_uri=None):
'''
Call Facebook me/permissions to see if we are allowed to do this
'''
from django_facebook.api import get_persistent_graph
fb = get_persistent_graph(request, redirect_uri=redirect_uri)
permissions_dict = {}
if fb:
#see what permissions we have
permissions_dict = fb.permissions()
# see if we have all permissions
scope_allowed = True
for permission in scope_list:
if permission not in permissions_dict:
scope_allowed = False
# raise if this happens after a redirect though
if not scope_allowed and request.GET.get('attempt'):
raise ValueError(
'Somehow facebook is not giving us the permissions needed, '
'lets break instead of endless redirects. Fb was %s and '
'permissions %s' % (fb, permissions_dict))
return scope_allowed
def wall_post(request):
fb = get_persistent_graph(request)
message = request.POST.get('message')
if message:
fb.set('me/feed', message=message)
messages.info(request, 'Posted the message to your wall')
return next_redirect(request)
def test_permissions(request, scope_list, redirect_uri=None):
'''
Call Facebook me/permissions to see if we are allowed to do this
'''
from django_facebook.api import get_persistent_graph
fb = get_persistent_graph(request, redirect_uri=redirect_uri)
permissions_dict = {}
if fb:
#see what permissions we have
permissions_dict = fb.permissions()
# see if we have all permissions
scope_allowed = True
for permission in scope_list:
if permission not in permissions_dict:
scope_allowed = False
# raise if this happens after a redirect though
if not scope_allowed and request.GET.get('attempt'):
raise ValueError(
'Somehow facebook is not giving us the permissions needed, '
'lets break instead of endless redirects. Fb was %s and '
'permissions %s' % (fb, permissions_dict))
return scope_allowed
def join_squad(request, game):
""" View to join a squad """
game_obj = get_game(game)
assassin_obj = game_obj.getAssassin(request.user)
if assassin_obj is None:
raise Http404
if request.method == 'POST':
form = JoinForm(request.POST, assassin=assassin_obj)
if form.is_valid():
squad = form.cleaned_data.get('squad')
squad.add_assassin(assassin_obj, commit=True)
try:
fb = api.get_persistent_graph(request, access_token=request.user.columbiauserprofile.access_token)
if fb:
url = 'http://assassins.columbiaesc.com' + reverse('assassins_manager.squad.views.details', args=(game_obj.name, squad.id, ))
result = fb.set('me/cuassassins:join', squad=url)
except:
pass
return HttpResponseRedirect(reverse('assassins_manager.squad.views.details', args=(game, squad.id,)))
else:
form = JoinForm(assassin=assassin_obj)
return render_with_metadata(request, 'form.html', game, {
'formname': 'Join Squad',
'form': form,
})
def remove_og_share(request):
graph = get_persistent_graph(request)
og_share_id = request.POST.get('og_share_id')
if og_share_id:
shares = OpenGraphShare.objects.filter(id=og_share_id)
for share in shares:
share.remove(graph)
def connect(request):
'''
Handles the view logic around connect user
- (if authenticated) connect the user
- login
- register
'''
context = RequestContext(request)
assert context.get('FACEBOOK_APP_ID'), 'Please specify a facebook app id '\
'and ensure the context processor is enabled'
facebook_login = bool(int(request.REQUEST.get('facebook_login', 0)))
if facebook_login:
logger.info('trying to connect using facebook')
graph = get_persistent_graph(request)
if graph:
logger.info('found a graph object')
facebook = FacebookUserConverter(graph)
if facebook.is_authenticated():
logger.info('facebook is authenticated')
facebook_data = facebook.facebook_profile_data()
#either, login register or connect the user
try:
action, user = connect_user(request)
logger.info('Django facebook performed action: %s', action)
except facebook_exceptions.IncompleteProfileError, e:
warn_message = u'Incomplete profile data encountered '\
u'with error %s' % e
send_warning(warn_message,
e=e,
facebook_data=facebook_data)
context['facebook_mode'] = True
context['form'] = e.form
return render_to_response(
facebook_settings.FACEBOOK_REGISTRATION_TEMPLATE,
context_instance=context,
)
if action is CONNECT_ACTIONS.CONNECT:
messages.info(
request,
_("You have connected your account "
"to %s's facebook profile") % facebook_data['name'])
elif action is CONNECT_ACTIONS.REGISTER:
return user.get_profile().post_facebook_registration(
request)
else:
if 'attempt' in request.GET:
return next_redirect(
request,
next_key=['error_next', 'next'],
additional_params=dict(fb_error_or_cancel=1))
else:
logger.info('Facebook authentication needed for connect, ' \
'raising an error')
raise OpenFacebookException('please authenticate')
return next_redirect(request)
def start_game(request, game):
""" Starts the game """
game_obj = get_game(game)
if is_admin(request.user, game_obj):
if request.method == 'POST':
form = VerifyForm(request.POST)
if form.is_valid():
if form.cleaned_data.get('are_you_sure'):
game_obj.start_game() # calls save internally
try:
fb = api.get_persistent_graph(request, access_token=request.user.columbiauserprofile.access_token)
if fb:
url = 'http://assassins.columbiaesc.com' + reverse('assassins_manager.game.views.details', args=(game_obj.name,))
result = fb.set('me/cuassassins:start', game=url)
except:
pass
return HttpResponseRedirect(reverse('assassins_manager.game.views.game_admin', args=(game,)))
else:
form = VerifyForm()
return render_with_metadata(request, 'form.html', game, {
'form': form,
'formname': 'Start Game',
})
else:
return HttpResponseRedirect(reverse('assassins_manager.game.views.details', args=(game,)))
def create_game(request):
""" Creates a new game and sets the existing user as the administrator """
if request.method == 'POST':
form = AddGameForm(request.POST)
if form.is_valid():
game_obj = form.save()
assassin_obj = Assassin(user=request.user)
assassin_obj.squad = None
assassin_obj.is_admin = True
assassin_obj.game = game_obj
assassin_obj.resurrect(commit=False)
assassin_obj.save()
try:
fb = api.get_persistent_graph(request, access_token=request.user.columbiauserprofile.access_token)
if fb:
url = 'http://assassins.columbiaesc.com' + reverse('assassins_manager.game.views.details', args=(game_obj.name,))
result = fb.set('me/cuassassins:create', game=url)
except:
pass
return HttpResponseRedirect(reverse('assassins_manager.game.views.game_admin', args=(game_obj.name,)))
else:
form = AddGameForm()
return render_with_metadata(request, 'form.html', '', {
'form': form,
'formname': 'Create Game',
})
def authenticate(self, fn, request, *args, **kwargs):
'''
Authenticate the user
There are three options
a.) We have permissions, proceed with the view
b.) We tried getting permissions and failed, abort...
c.) We are about to ask for permissions
'''
redirect_uri = self.get_redirect_uri(request)
oauth_url = get_oauth_url(self.scope_list,
redirect_uri,
extra_params=self.extra_params)
graph = get_persistent_graph(request, redirect_uri=redirect_uri)
# See if we have all permissions
permissions_granted = has_permissions(graph, self.scope_list)
if permissions_granted:
response = self.execute_view(fn,
request,
graph=graph,
*args,
**kwargs)
elif request.REQUEST.get('attempt') == '1':
# Doing a redirect could end up causing infinite redirects
# If Facebook is somehow not giving permissions
# Time to show an error page
response = self.authentication_failed(fn, request, *args, **kwargs)
else:
response = self.oauth_redirect(oauth_url, redirect_uri)
return response
def home( request ):
try:
#graph = user.get_offline_graph( )
graph = get_persistent_graph( request )
fm = graph.get( 'me' )
except:
fm = ''
return render( request, 'home.html', {'fm': fm } )
def remove_og_share(request):
from django_facebook.models import OpenGraphShare
graph = get_persistent_graph(request)
og_share_id = request.POST.get('og_share_id')
if og_share_id:
shares = OpenGraphShare.objects.filter(id=og_share_id)
for share in shares:
share.remove(graph)
def remove_og_share(request):
from django_facebook.models import OpenGraphShare
graph = get_persistent_graph(request)
og_share_id = request.POST.get('og_share_id')
if og_share_id:
shares = OpenGraphShare.objects.filter(id=og_share_id)
for share in shares:
share.remove(graph)
def enviarApagina(request):
context = RequestContext(request)
if request.method == 'POST':
mensaje = request.POST.get('mensaje')
fb = get_persistent_graph(request)
fb.set('323555591081578/feed', message = mensaje)
return HttpResponseRedirect('/')
return render_to_response('home.html', context)
def open_graph_beta(request):
'''
Simple example on how to do open graph postings
'''
fb = get_persistent_graph(request)
entity_url = 'http://www.fashiolista.com/item/2081202/'
result = fb.set('me/fashiolista:love', item=entity_url)
messages.info(request, 'Frictionless sharing to open graph beta action fashiolista:love with item_url %s, this url contains open graph data which Facebook scrapes' % entity_url)
def get_facebook_user_id(request):
graph = get_persistent_graph(request)
user_facebook_info = graph.get('me')
if user_facebook_info and 'id' in user_facebook_info:
return user_facebook_info['id']
else:
raise Exception('Error while getting user facebook id. Please inform administrator.')
def checkin(request):
fb = get_persistent_graph(request)
event_url = request.GET.get("event_url")
if CheckIn.objects.filter(user=request.user, event_url=event_url).exists():
return HttpResponseNotAllowed('Already checked in here.')
fb.set("me/maivnapp:check_in", website=event_url)
CheckIn.objects.create(user=request.user, event_url=event_url)
return HttpResponse("OK")
def friends(self, request):
"""
Gets Profiles of Facebook Friends
"""
fb = get_persistent_graph(request)
# TODO: iterate over the pagination info
fbids = [int(i['id']) for i in fb.get('me/friends').get('data')]
return Profile.objects.filter(facebook_id__in=fbids)
def open_graph_beta(request):
'''
Simple example on how to do open graph postings
'''
fb = get_persistent_graph(request)
entity_url = 'http://www.fashiolista.com/item/2081202/'
result = fb.set('me/fashiolista:love', item=entity_url)
messages.info(request, 'Frictionless sharing to open graph beta action fashiolista:love with item_url %s, this url contains open graph data which Facebook scrapes' % entity_url)
def connect(request):
'''
Handles the view logic around connect user
- (if authenticated) connect the user
- login
- register
'''
backend = get_registration_backend()
context = RequestContext(request)
assert context.get('FACEBOOK_APP_ID'), 'Please specify a facebook app id '\
'and ensure the context processor is enabled'
facebook_login = bool(int(request.REQUEST.get('facebook_login', 0)))
if facebook_login:
require_persistent_graph(request)
logger.info('trying to connect using facebook')
graph = get_persistent_graph(request)
if graph:
logger.info('found a graph object')
facebook = FacebookUserConverter(graph)
if facebook.is_authenticated():
logger.info('facebook is authenticated')
facebook_data = facebook.facebook_profile_data()
#either, login register or connect the user
try:
action, user = connect_user(request)
logger.info('Django facebook performed action: %s', action)
except facebook_exceptions.IncompleteProfileError, e:
warn_message = u'Incomplete profile data encountered '\
u'with error %s' % e.message.decode('utf-8', 'replace')
send_warning(warn_message, e=e,
facebook_data=facebook_data)
context['facebook_mode'] = True
context['form'] = e.form
return render_to_response(
facebook_settings.FACEBOOK_REGISTRATION_TEMPLATE,
context_instance=context,
)
if action is CONNECT_ACTIONS.CONNECT:
messages.info(request, _("You have connected your account "
"to %s's facebook profile") % facebook_data['name'])
elif action is CONNECT_ACTIONS.REGISTER:
response = backend.post_registration_redirect(request, user)
return response
else:
if 'attempt' in request.GET:
return next_redirect(request, next_key=['error_next', 'next'],
additional_params=dict(fb_error_or_cancel=1))
else:
logger.info('Facebook authentication needed for connect, ' \
'raising an error')
raise OpenFacebookException('please authenticate')
return next_redirect(request)
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 wall_post(request):
fb = get_persistent_graph(request)
message = request.REQUEST.get("message")
fb.set("me/feed", message=message)
messages.info(request, "Posted the message to your wall")
return next_redirect(request)
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 canvas(request):
context = RequestContext(request)
context['auth_url'] = generate_oauth_url()
fb = get_persistent_graph(request)
if fb.is_authenticated():
likes = context['facebook'].get_connections("me", "likes", limit=3)
logger.info('found these likes %s', likes)
return render_to_response('django_facebook/canvas.html', context)
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 canvas(request):
context = RequestContext(request)
context['auth_url'] = generate_oauth_url()
fb = get_persistent_graph(request)
if fb.is_authenticated():
likes = context['facebook'].get_connections("me", "likes", limit=3)
logger.info('found these likes %s', likes)
return render_to_response('django_facebook/canvas.html', context)
def image_upload(request):
fb = get_persistent_graph(request)
pictures = request.REQUEST.getlist("pictures")
for picture in pictures:
fb.set("me/photos", url=picture, message="the writing is one The " "wall image %s" % picture)
messages.info(request, "The images have been added to your profile!")
return next_redirect(request)
def map(request):
graph = get_persistent_graph(request)
pics = graph.fql("SELECT pic_square FROM user WHERE uid IN (SELECT uid2 FROM friend WHERE uid1 = me())")
pic = list()
for li in pics:
s = li.get('pic_square')
if s is not None:
pic.append(s.encode('ascii','ignore'))
pic=json.dumps(pic)
return render(request,'hellodjango/templates/mmap.html',{'pic':pic})
def fbconnect(request):
# Calling the real facebook connect() view
response = connect(request)
if not 'facebook_login' in request.REQUEST:
fbid = get_persistent_graph(request).get('me')['id']
user = authenticate(facebook_id=fbid)
login(request, user)
response.status_code = 302
response['Location'] = '/'
return response
def get_facebook_user_id(request):
graph = get_persistent_graph(request)
user_facebook_info = graph.get('me')
if user_facebook_info and 'id' in user_facebook_info:
return user_facebook_info['id']
else:
raise Exception(
'Error while getting user facebook id. Please inform administrator.'
)
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 connect(request):
"""
Handles the view logic around connect user
- (if authenticated) connect the user
- login
- register
"""
context = RequestContext(request)
assert context.get("FACEBOOK_APP_ID"), (
"Please specify a facebook app id " "and ensure the context processor is enabled"
)
facebook_login = bool(int(request.REQUEST.get("facebook_login", 0)))
if facebook_login:
# code to redirect if we don't have adequate permissions
from django_facebook.utils import test_permissions
scope_list = facebook_settings.FACEBOOK_DEFAULT_SCOPE
# standardizing the url to prevent things like attempt from being included
redirect_uri = request.build_absolute_uri(request.path) + "?facebook_login=1"
oauth_url, redirect_uri = get_oauth_url(request, scope_list, redirect_uri=redirect_uri)
if not test_permissions(request, scope_list, redirect_uri):
return HttpResponseRedirect(oauth_url)
graph = get_persistent_graph(request)
if graph:
facebook = FacebookUserConverter(graph)
if facebook.is_authenticated():
facebook_data = facebook.facebook_profile_data()
# either, login register or connect the user
try:
action, user = connect_user(request)
logger.info("Django facebook, action was %s", action)
except facebook_exceptions.IncompleteProfileError, e:
warn_message = u"Incomplete profile data encountered " u"with error %s" % e
send_warning(warn_message, e=e, facebook_data=facebook.facebook_profile_data())
context["facebook_mode"] = True
context["form"] = e.form
return render_to_response(
facebook_settings.FACEBOOK_REGISTRATION_TEMPLATE, context_instance=context
)
if action is CONNECT_ACTIONS.CONNECT:
messages.info(
request,
_("You have connected your account " "to %s's facebook profile") % facebook_data["name"],
)
elif action is CONNECT_ACTIONS.REGISTER:
return user.get_profile().post_facebook_registration(request)
else:
return next_redirect(request, next_key=["error_next", "next"], additional_params=dict(fb_error_or_cancel=1))
return next_redirect(request)
def image_upload(request):
fb = get_persistent_graph(request)
pictures = request.REQUEST.getlist('pictures')
for picture in pictures:
fb.set('me/photos', url=picture, message='the writing is one The '
'wall image %s' % picture)
messages.info(request, 'The images have been added to your profile!')
return next_redirect(request)
def test_long_username(self):
request = RequestMock().get('/')
request.session = {}
request.user = AnonymousUser()
graph = get_persistent_graph(request, access_token='long_username')
converter = FacebookUserConverter(graph)
base_data = converter.facebook_registration_data()
action, user = connect_user(self.request, facebook_graph=graph)
self.assertEqual(len(base_data['username']), 30)
self.assertEqual(len(user.username), 30)
self.assertEqual(len(user.first_name), 30)
self.assertEqual(len(user.last_name), 30)
def test_gender_matching(self):
request = RequestMock().get('/')
request.session = {}
request.user = AnonymousUser()
graph = get_persistent_graph(request, access_token='paul')
converter = FacebookUserConverter(graph)
base_data = converter.facebook_profile_data()
self.assertEqual(base_data['gender'], 'male')
data = converter.facebook_registration_data()
self.assertEqual(data['gender'], 'm')
action, user = connect_user(self.request, facebook_graph=graph)
self.assertEqual(user.get_profile().gender, 'm')
def wall_post(request):
'''
Handle image uploading to Facebook
'''
fb = get_persistent_graph(request)
if fb.is_authenticated():
#handling the form without a form class for explanation
#in your own app you could use a neat django form to do this
message = request.POST.get('message')
fb.set('me/feed', message=message)
from django.contrib import messages
messages.info(request, 'Posted the message to your wall')
return next_redirect(request)
def __init__(self, request, place, page_url):
""" Create a new facebook import service object.
@type request: django.core.handlers.wsgi.WSGIRequest
@type place: str
@param place: city for search and filter by
@type page_url: str
@param page_url: facebook page url (events owner)
"""
self.request = request
self.place = place
self.page_url = page_url
self.page = 0
self.graph = get_persistent_graph(request)
self.lower_place = self.place.lower()
def connect_async_ajax(request):
'''
Not yet implemented:
The idea is to run the entire connect flow on the background using celery
Freeing up webserver resources, when facebook has issues
'''
from django_facebook import tasks as facebook_tasks
graph = get_persistent_graph(request)
output = {}
if graph:
facebook = FacebookUserConverter(graph)
task = facebook_tasks.async_connect_user(request, graph)
output['task_id'] = task.id
from open_facebook.utils import json
json_dump = json.dumps(output)
return HttpResponse(json_dump)
def image_upload(request):
fb = get_persistent_graph(request)
print request
if request.FILES:
print "123"
pictures = request.POST.getlist('images')
print pictures
for picture in pictures:
fb.set('me/photos',
url="http://asdasd.asd",
message='the writing is one The '
'wall image %s' % picture)
messages.info(request, 'The images have been added to your profile!')
return next_redirect(request)
return render(request, 'send_images.html')
def image_upload(request):
'''
Handle image uploading to Facebook
'''
fb = get_persistent_graph(request)
if fb.is_authenticated():
#handling the form without a form class for explanation
#in your own app you could use a neat django form to do this
pictures = request.POST.getlist('pictures')
from django.contrib import messages
for picture in pictures:
fb.set('me/photos', url=picture, message='the writing is one The '
'wall image %s' % picture)
messages.info(request, 'The images have been added to your profile!')
return next_redirect(request)
def test_permissions(request, scope_list, redirect_uri=None):
'''
Call Facebook me/permissions to see if we are allowed to do this
'''
from django_facebook.api import get_persistent_graph
from open_facebook import exceptions as facebook_exceptions
fb = get_persistent_graph(request, redirect_uri=redirect_uri)
permissions_dict = {}
if fb:
try:
permissions_response = fb.get('me/permissions')
permissions = permissions_response['data'][0]
except facebook_exceptions.OAuthException, e:
#this happens when someone revokes their permissions while the session
#is still stored
permissions = {}
permissions_dict = dict([(k,bool(int(v))) for k,v in permissions.items() if v == '1' or v == 1])
def test_update_access_token(self):
request = RequestMock().get('/')
request.session = {}
request.user = AnonymousUser()
graph = get_persistent_graph(request, access_token='paul')
action, user = connect_user(self.request, facebook_graph=graph)
first_user_id = user.id
# new token required should start out as False
profile = try_get_profile(user)
new_token_required = get_user_attribute(user, profile,
'new_token_required')
self.assertEqual(new_token_required, False)
# we manually set it to true
update_user_attributes(user,
profile,
dict(new_token_required=True),
save=True)
if profile:
profile = get_profile_model().objects.get(id=profile.id)
user = get_user_model().objects.get(id=user.id)
new_token_required = get_user_attribute(user, profile,
'new_token_required')
self.assertEqual(new_token_required, True)
# another update should however set it back to False
request.facebook = None
graph = get_facebook_graph(request, access_token='paul2')
logger.info('and the token is %s', graph.access_token)
action, user = connect_user(self.request, facebook_graph=graph)
user = get_user_model().objects.get(id=user.id)
self.assertEqual(user.id, first_user_id)
if profile:
profile = get_profile_model().objects.get(id=profile.id)
user = get_user_model().objects.get(id=user.id)
new_token_required = get_user_attribute(user, profile,
'new_token_required')
self.assertEqual(new_token_required, False)
def post(request):
if request.method == 'POST':
form = PictureForm(request.POST, request.FILES)
if form.is_valid():
picture = form.save(commit=False)
picture.owner = request.user
picture.save()
#Adding brands to picture
words = input_to_words(request.POST['brands'])
add_brands(words, picture)
fb = get_persistent_graph(request)
picture_to_upload = picture.get_url()
fb.set('me/photos',
url=picture_to_upload,
message=picture.description)
messages.info(request, 'Imagen subida correctamente')
return HttpResponseRedirect('/pictures/view/%s' % (picture.pk))
else:
form = PictureForm()
return render_to_response('pictures/post.html', {'form': form},
context_instance=RequestContext(request))
def test_persistent_graph(self):
from django.test import RequestFactory
request = RequestFactory()
request.session = {}
request.user = AnonymousUser()
get_persistent_graph(request, access_token='short_username')
def create_facebook_event(event,
request,
facebook_owner_id,
facebook_owner_type='user'):
graph = get_persistent_graph(request)
if not graph:
raise Exception('Error: facebook authentication is required')
parser = HTMLParser()
description = strip_tags(parser.unescape(event.description))
googlemap_link = 'http://maps.google.com/?ie=UTF8&hq=&q=%s,%s&ll=%s,%s&z=13' % (
event.location.y, event.location.x, event.location.y, event.location.x)
description = '%s\r\n\nLocation: %s\r\n\nPrice: %s' % (
description, googlemap_link, event.price)
if facebook_owner_type == 'user' and event.tickets:
description = '%s\r\n\nTickets: %s' % (description, event.tickets)
location = event.venue.name
if event.venue.street:
location += ', %s' % event.venue.street
location += ', %s' % event.venue.city.name_std
dates = Event.events.annotate(start_time=Min('single_events__start_time'))\
.annotate(end_time=Max('single_events__end_time')).get(pk=event.id)
if dates.start_time >= dates.end_time:
dates.end_time += datetime.timedelta(days=1)
common_params = {
'name': shorten_string(event.name, 72), # max length is 75 (with ...)
'description': unicode(description).encode('utf-8'),
'location': location
}
if facebook_owner_type == 'page' and event.tickets:
validate = URLValidator()
try:
validate(event.tickets)
common_params['ticket_uri'] = event.tickets
except ValidationError:
pass
if event.is_multiday():
single_events = list(SingleEvent.homepage_events.filter(event=event))
else:
single_events = list(SingleEvent.future_events.filter(event=event))
event_url = '%s/events' % facebook_owner_id
event_images = list(event.sorted_images)
have_images = False
if len(event_images) > 0:
event_image = os.path.abspath(
os.path.join(settings.MEDIA_ROOT, event_images[0].picture.path))
have_images = True
event_groups, event_group = [], []
index = 0
for single_event in single_events:
event_group.append(single_event)
index += 1
if index == 10:
event_groups.append(event_group)
index, event_group = 0, []
if index != 0:
event_groups.append(event_group)
facebook_event_ids, posted_single_events = [], []
for event_group in event_groups:
batch, attached_images = [], {}
for single_event in event_group:
if not single_event.facebook_event:
posted_single_events.append(single_event)
params = common_params.copy()
params.update({
'start_time':
single_event.start_time.strftime('%Y-%m-%dT%H:%M:%S-0600'),
'end_time':
single_event.end_time.strftime('%Y-%m-%dT%H:%M:%S-0600'),
})
operation_name = 'create-event-%s' % single_event.id
batch.append({
'method': 'POST',
'relative_url': event_url,
'body': urllib.urlencode(params),
'name': operation_name,
'omit_response_on_success': False
})
if have_images:
picture_url = '{result=%s:$.id}/picture' % operation_name
image_name = 'source%s' % single_event.id
batch.append({
'method': 'POST',
'relative_url': picture_url,
'attached_files': image_name
})
attached_images[image_name] = open(event_image)
if posted_single_events:
values = {
'access_token': graph.access_token,
'batch': json.dumps(batch)
}
if have_images:
values.update(attached_images)
response = _send_multipart_data(graph.api_url, values)
for item in response:
data = json.loads(item['body'])
if type(data) == dict and 'id' in data:
facebook_event_ids.append(data['id'])
if not posted_single_events:
raise Exception('Error: no events for posting')
result = {}
for i in range(0, len(posted_single_events)):
attach_facebook_event(int(facebook_event_ids[i]),
posted_single_events[i])
result[posted_single_events[i].id] = facebook_event_ids[i]
if event.is_multiday():
single_event = SingleEvent.objects.filter(event=event,
is_occurrence=False)[0]
single_event.facebook_event = posted_single_events[0].facebook_event
single_event.save()
return result
def test_get_persistent(self):
graph = get_persistent_graph(self.request)
# fake that we are authenticated and have a facebook graph
with patch.object(self.request, 'facebook'):
self.request.user = get_user_model().objects.all()[:1][0]
graph = get_persistent_graph(self.request)
def get_prepared_event_data(request, data):
"""
@todo Refactor - split on several methods
"""
graph = get_persistent_graph(request)
facebook_event = graph.fql('''select name,
start_time,
end_time,
description,
pic_big,
pic_cover,
location,
venue,
ticket_uri
from event
where eid = %s''' %
data['facebook_event_id'])[0]
if type(facebook_event['start_time']) == int:
start_time = datetime.datetime.fromtimestamp(
facebook_event['start_time'])
else:
start_time = dateparser.parse(facebook_event['start_time'])
if 'end_time' in facebook_event and facebook_event['end_time']:
if type(facebook_event['end_time']) == int:
end_time = datetime.datetime.fromtimestamp(
facebook_event['end_time'])
else:
end_time = dateparser.parse(facebook_event['end_time'])
else:
end_time = start_time + datetime.timedelta(hours=3)
image_source = facebook_event['pic_cover']['source'] if facebook_event['pic_cover'] \
and 'source' in facebook_event['pic_cover'] \
else facebook_event['pic_big']
location = city = street = ''
longitude = latitude = 0
if facebook_event['venue']:
location = facebook_event.get('location', '')
city = facebook_event['venue'].get('city', '')
street = facebook_event['venue'].get('street', '')
longitude = facebook_event['venue'].get('longitude', 0)
latitude = facebook_event['venue'].get('latitude', 0)
if not (city and longitude and latitude):
location = city = street = ''
longitude = latitude = 0
location_data = {
'place': location,
'geo_venue': location,
'geo_street': street,
'geo_street_number': '',
'geo_city': city,
'geo_longtitude': longitude,
'location_lng': longitude,
'geo_latitude': latitude,
'location_lat': latitude,
'venue_name': ''
}
description = facebook_event['description'].replace('\n', '<br />\n')
result = {
'name':
facebook_event['name'],
'user_context_type':
'account',
'user_context_id':
request.account.id,
'family':
False,
'date_night':
False,
'wheelchair':
False,
'website':
'https://www.facebook.com/events/' + data['facebook_event_id'],
'when':
start_time.strftime('%d-%m-%Y'),
'when_json':
_get_time_range_json(start_time, end_time),
'price':
'$',
'description':
description,
'description_json':
json.dumps({
'default': description,
'days': {
start_time.strftime('%m/%d/%Y'): description
}
}),
'tags':
'',
'tickets':
facebook_event['ticket_uri'],
'images':
_get_images_json(image_source),
'picture_src':
'',
'cropping':
'',
'linking_venue_mode':
'GOOGLE',
'event_type':
'SINGLE',
'occurrences_json': []
}
result.update(location_data)
return result
