def friendslist(request):
#try:
graph = get_facebook_graph(request)
facebook = FacebookUserConverter(graph)
#groups = facebook.get_groups()
items = facebook.get_free_for_sale()
#print json.dumps(items, sort_keys=True, indent=4, separators=(',', ': '))
for item in items:
thumbnail_url = item.get('picture')
if thumbnail_url:
link = item.get('link')
fb_id = parse_qs(urlparse(link).query)['fbid'][0]
# print(fb_id)
picture = facebook.get_facebook_url(fb_id)
# print(picture)
picture_url = picture.get('source')
# print(picture_url)
#print items
#friends = facebook.get_friends()
#likes = facebook.get_likes()
#store_likes = facebook.get_and_store_likes(request.user)
#print(groups)
#print(store_likes)
#print(queryset)
#context_object_name = 'my_friends_list'
#template_name = "friendslist.html"
#except OpenFacebookException as e:
# print(e)
#except:
# raise Http404
update_index.Command().handle(using='default', remove=True)
return render_to_response('friendslist.html', {'items': items},
context_instance=RequestContext(request))
def free_for_sale_post(request, item):
graph = require_persistent_graph(request)
try:
graph.is_authenticated()
facebook = FacebookUserConverter(graph)
response = facebook.set_free_for_sale(item)
return response
except OAuthException:
return None
except AttributeError:
return None # Not Facebook Account
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)
profile = try_get_profile(user)
gender = get_user_attribute(user, profile, 'gender')
self.assertEqual(gender, 'm')
def test_user_registered_signal(self):
# Ensure user registered, pre update and post update signals fire
def user_registered(sender, user, facebook_data, **kwargs):
user.registered_signal = True
def pre_update(sender, user, profile, facebook_data, **kwargs):
user.pre_update_signal = True
def post_update(sender, user, profile, facebook_data, **kwargs):
user.post_update_signal = True
Profile = get_profile_model()
user_model = get_user_model()
signals.facebook_user_registered.connect(user_registered,
sender=user_model)
signals.facebook_pre_update.connect(pre_update, sender=user_model)
signals.facebook_post_update.connect(post_update, sender=user_model)
graph = get_facebook_graph(access_token='short_username')
facebook = FacebookUserConverter(graph)
user = _register_user(self.request, facebook)
self.assertEqual(hasattr(user, 'registered_signal'), True)
self.assertEqual(hasattr(user, 'pre_update_signal'), True)
self.assertEqual(hasattr(user, 'post_update_signal'), True)
def test_parallel_register(self):
'''
Adding some testing for the case when one person tries to register
multiple times in the same second
'''
graph = get_facebook_graph(access_token='short_username')
FacebookUserConverter(graph)
action, user = connect_user(self.request, facebook_graph=graph)
self.assertEqual(action, CONNECT_ACTIONS.REGISTER)
self.request.user.is_authenticated = lambda: False
with patch('django_facebook.connect.authenticate') as patched:
return_sequence = [user, None]
def side(*args, **kwargs):
value = return_sequence.pop()
return value
patched.side_effect = side
with patch('django_facebook.connect._register_user'
) as patched_register:
patched_register.side_effect = facebook_exceptions.AlreadyRegistered(
'testing parallel registers')
action, user = connect_user(self.request, facebook_graph=graph)
self.assertEqual(action, CONNECT_ACTIONS.LOGIN)
def test_persistent_graph(self):
request = RequestMock().get('/')
request.session = {}
request.user = AnonymousUser()
graph = get_facebook_graph(access_token='short_username')
FacebookUserConverter(graph)
action, user = connect_user(self.request, facebook_graph=graph)
self.assertEqual(action, CONNECT_ACTIONS.REGISTER)
def fb_group_post(request, item, fb_group):
'''
:param request:
:param item: ItemForSale Model
:param fb_group: URL of group, e.g. '1223124/feed/'
:return: response if successful
# try:
import urllib2
code = urllib2.urlopen('https://www.facebook.com/dialog/oauth?client_id='+
settings.FACEBOOK_APP_ID + '&redirect_uri='+
settings.FACEBOOK_REDIRECT_URI + '&scope=read_stream')
f = urllib2.urlopen('https://graph.facebook.com/oauth/access_token?client_id='+
settings.FACEBOOK_APP_ID + '&client_secret=' + settings.FACEBOOK_APP_SECRET +
'&grant_type=client_credentials')
data = f.read()
print(data) # access_token=171685159547122|he8_Dw5MqyosrndHcDal9t588UQ
access_token = data.split('|')[0].lstrip('access_token=')
test = urllib2.urlopen(settings.FACEBOOK_REDIRECT_URI)
from open_facebook.api import FacebookAuthorization
token_response = FacebookAuthorization.convert_code(
code, redirect_uri=redirect_uri)
expires = token_response.get('expires')
access_token = token_response['access_token']
from django_facebook.connect import connect_user
action, user = connect_user(request)'''
graph = require_persistent_graph(request)
try:
graph.is_authenticated()
facebook = FacebookUserConverter(graph)
response = facebook.set_fb_group(item, fb_group)
return response
except OAuthException:
return None
except AttributeError:
return None # Not Facebook Account
def test_full_connect(self):
# going for a register, connect and login
graph = get_facebook_graph(access_token='short_username')
FacebookUserConverter(graph)
action, user = connect_user(self.request, facebook_graph=graph)
self.assertEqual(action, CONNECT_ACTIONS.REGISTER)
# and now we do a login, not a connect
action, user = connect_user(self.request, facebook_graph=graph)
self.assertEqual(action, CONNECT_ACTIONS.LOGIN)
self.request.GET._mutable = True
self.request.GET['connect_facebook'] = 1
action, user = connect_user(self.request,
facebook_graph=graph,
connect_facebook=True)
self.assertEqual(action, CONNECT_ACTIONS.CONNECT)
self.request.user = AnonymousUser()
action, user = connect_user(self.request,
facebook_graph=graph,
connect_facebook=True)
self.assertEqual(action, CONNECT_ACTIONS.LOGIN)
def test_gender(self):
graph = get_facebook_graph(access_token='new_user')
facebook = FacebookUserConverter(graph)
data = facebook.facebook_registration_data()
self.assertEqual(data['gender'], 'm')
def test_utf8(self):
graph = get_facebook_graph(access_token='unicode_string')
facebook = FacebookUserConverter(graph)
action, user = connect_user(self.request, facebook_graph=graph)
def fb_import(request):
if request.method == 'GET':
existing_groups = []
new_groups = []
data = {}
if request.user.is_authenticated():
user_profile = request.user.get_profile()
my_circles = user_profile.my_circles.all()
my_circles_id = [o.id for o in my_circles]
try:
graph = get_facebook_graph(request)
facebook = FacebookUserConverter(graph)
groups = facebook.get_groups()
#friends = facebook.get_friends()
groups = sorted(groups,
key=lambda group: group['bookmark_order'])
for group in groups:
try:
existing = Circle.objects.get(fb_id=group['id'])
if existing not in my_circles:
existing_groups.append(existing)
except:
new_groups.append(group)
except:
existing_groups = Circle.objects.filter(
is_public=True).exclude(
id__in=my_circles_id).order_by('?')[:5]
if not existing_groups:
existing_groups = Circle.objects.filter(
is_public=True).exclude(
id__in=my_circles_id).order_by('?')[:5]
data['existing_groups'] = existing_groups
data['new_groups'] = new_groups
user_profile.first_time = False
user_profile.save()
return render_to_response('fb_import.html',
data,
context_instance=RequestContext(request))
else:
user_profile = request.user.get_profile()
create_groups = request.POST.getlist("createFbId")
create_groups = map(int, create_groups)
join_groups = request.POST.getlist("joinGroupId")
graph = get_facebook_graph(request)
facebook = FacebookUserConverter(graph)
groups = facebook.get_groups()
for group in groups:
#print(group['id'])
if not Circle.objects.filter(fb_id=group['id']) and int(
group['id']) in create_groups:
name = group[
'name'][:
100] #this 100 comes from the circle name model max length
circle = Circle.objects.create(name=group['name'],
creator=request.user,
fb_id=group['id'],
url_key=Circle.make_key(),
is_public=True)
user_profile.my_circles.add(circle)
for group_id in join_groups:
group = Circle.objects.get(id=group_id)
user_profile.my_circles.add(group)
return redirect(
'/accounts/profile/groups/?msg=Groups have been successfully updated!'
)
def fb_to_excel(request):
data = {}
ffs_items = txtbook_items = clothes_items = []
choices = ''
limit = 1000
existing = ''
new_items = []
import time
until = datetime.datetime.utcnow()
until = time.mktime(until.timetuple())
since = 0
if 'choices' in request.GET:
choices = request.GET['choices']
if 'limit' in request.GET:
limit = int(request.GET['limit'])
if 'existing' in request.GET:
existing = request.GET['existing']
if 'until' in request.GET:
until = request.GET['until']
if 'since' in request.GET:
since = request.GET['since']
if not existing:
try:
graph = get_facebook_graph(request)
facebook = FacebookUserConverter(graph)
if not choices or 'ffs' in choices:
ffs_items = facebook.get_free_for_sale(limit=limit)
if not choices or 'txt' in choices:
txtbook_items = facebook.get_textbook_exchange(limit=limit)
if not choices or 'cls' in choices:
clothes_items = facebook.get_facebook_data(
'429395210488691/feed', limit=limit)
except:
data['title'] = 'Relogin to Facebook'
data['message'] = 'Your login has expired. Relogin ya doof.'
return render_to_response('message.html',
data,
context_instance=RequestContext(request))
items = ffs_items + txtbook_items + clothes_items
new_items = save_fb_items_to_model(facebook, items)
existing_items = FacebookPostForExcel.objects.all()
response = HttpResponse(content_type='text/csv')
response['Content-Disposition'] = 'attachment; filename="FB-items.csv"'
import cc.unicodecsv as csv
writer = csv.writer(response)
'''
message=message,
user_id=user_id,
facebook_id=item_id,
seller_name=seller_name,
post_url=post_url,
thumbnail_url=thumbnail_url,
picture_url=picture_url,
price=price,
created_time=created_time
'''
writer.writerow([
'Created_Time', 'Message', 'Post Url', 'Seller Name', 'Picture Url',
'Price', 'Comments', 'Likes'
])
db_items = new_items
if existing:
db_items = existing_items
for item in db_items:
try:
updated_time = item.updated_time.isoformat()
except:
updated_time = "None"
writer.writerow([
updated_time, item.message, item.post_url, item.seller_name,
item.picture_url,
str(item.price), item.num_comments, item.num_likes
])
return response