def store_likes(self, user, limit=1000, store=facebook_settings.FACEBOOK_STORE_LIKES):
from django_facebook.models import FacebookLike
likes_response = self.get_connections('me', 'likes', limit=limit)
likes = likes_response and likes_response.get('data')
logger.info('found %s likes', len(likes))
if likes and store:
base_queryset = FacebookLike.objects.filter(user=user)
global_defaults = dict(user=user)
id_field = 'facebook_id'
default_dict = {}
for like in likes:
name = like.get('name')
created_time = datetime.datetime.strptime(like['created_time'], "%Y-%m-%dT%H:%M:%S+0000")
default_dict[like['id']] = dict(
created_time = created_time,
category = like['category'],
name = name
)
current_likes, inserted_likes = mass_get_or_create(
FacebookLike, base_queryset, id_field, default_dict, global_defaults
)
logger.debug('found %s likes and inserted %s new likes', len(current_likes), len(inserted_likes))
return likes
def _store_likes(self, user, likes):
current_likes = inserted_likes = None
if likes:
from django_facebook.models import FacebookLike
base_queryset = FacebookLike.objects.filter(user_id=user.id)
global_defaults = dict(user_id=user.id)
id_field = 'facebook_id'
default_dict = {}
for like in likes:
name = like.get('name')
created_time_string = like.get('created_time')
created_time = None
if created_time_string:
created_time = parse_date(like['created_time'])
default_dict[like['id']] = dict(
created_time=created_time,
category=like.get('category'),
name=name
)
current_likes, inserted_likes = mass_get_or_create(
FacebookLike, base_queryset, id_field, default_dict,
global_defaults)
logger.debug('found %s likes and inserted %s new likes',
len(current_likes), len(inserted_likes))
# fire an event, so u can do things like personalizing the users' account
# based on the likes
signals.facebook_post_store_likes.send(sender=get_profile_model(),
user=user, likes=likes, current_likes=current_likes,
inserted_likes=inserted_likes,
)
return likes
def _store_friends(self, user, friends):
from django_facebook.models import FacebookUser
current_friends = inserted_friends = None
#store the users for later retrieval
if friends:
#see which ids this user already stored
base_queryset = FacebookUser.objects.filter(user_id=user.id)
global_defaults = dict(user_id=user.id)
default_dict = {}
for f in friends:
name = f.get('name')
default_dict[str(f['id'])] = dict(name=name)
id_field = 'facebook_id'
current_friends, inserted_friends = mass_get_or_create(
FacebookUser, base_queryset, id_field, default_dict,
global_defaults)
logger.debug('found %s friends and inserted %s new ones',
len(current_friends), len(inserted_friends))
#fire an event, so u can do things like personalizing suggested users
#to follow
signals.facebook_post_store_friends.send(sender=get_profile_class(),
user=user, friends=friends, current_friends=current_friends,
inserted_friends=inserted_friends,
)
return friends
def _store_likes(self, user, likes):
current_likes = inserted_likes = None
if likes:
from django_facebook.models import FacebookLike
base_queryset = FacebookLike.objects.filter(user_id=user.id)
global_defaults = dict(user_id=user.id)
id_field = 'facebook_id'
default_dict = {}
for like in likes:
name = like.get('name')
created_time_string = like.get('created_time')
created_time = None
if created_time_string:
created_time = parse_date(like['created_time'])
default_dict[like['id']] = dict(created_time=created_time,
category=like.get('category'),
name=name)
current_likes, inserted_likes = mass_get_or_create(
FacebookLike, base_queryset, id_field, default_dict,
global_defaults)
logger.debug('found %s likes and inserted %s new likes',
len(current_likes), len(inserted_likes))
# fire an event, so u can do things like personalizing the users' account
# based on the likes
signals.facebook_post_store_likes.send(
sender=get_profile_model(),
user=user,
likes=likes,
current_likes=current_likes,
inserted_likes=inserted_likes,
)
return likes
def _store_friends(self, user, friends):
from django_facebook.models import FacebookUser
current_friends = inserted_friends = None
#store the users for later retrieval
if friends:
#see which ids this user already stored
base_queryset = FacebookUser.objects.filter(user_id=user.id)
global_defaults = dict(user_id=user.id)
default_dict = {}
for f in friends:
name = f.get('name')
default_dict[str(f['id'])] = dict(name=name)
id_field = 'facebook_id'
current_friends, inserted_friends = mass_get_or_create(
FacebookUser, base_queryset, id_field, default_dict,
global_defaults)
logger.debug('found %s friends and inserted %s new ones',
len(current_friends), len(inserted_friends))
#fire an event, so u can do things like personalizing suggested users
#to follow
signals.facebook_post_store_friends.send(
sender=get_profile_class(),
user=user,
friends=friends,
current_friends=current_friends,
inserted_friends=inserted_friends,
)
return friends
def _store_likes(self, user, likes):
if likes:
from django_facebook.models import FacebookLike
base_queryset = FacebookLike.objects.filter(user_id=user.id)
global_defaults = dict(user_id=user.id)
id_field = 'facebook_id'
default_dict = {}
for like in likes:
name = like.get('name')
created_time_string = like.get('created_time')
created_time = None
if created_time_string:
created_time = datetime.datetime.strptime(
like['created_time'], "%Y-%m-%dT%H:%M:%S+0000")
default_dict[like['id']] = dict(
created_time=created_time,
category=like.get('category'),
name=name
)
current_likes, inserted_likes = mass_get_or_create(
FacebookLike, base_queryset, id_field, default_dict,
global_defaults)
logger.debug('found %s likes and inserted %s new likes',
len(current_likes), len(inserted_likes))
return likes
def _store_likes(self, user, likes):
current_likes = inserted_likes = None
if likes:
from django_facebook.models import FacebookLike
base_queryset = FacebookLike.objects.filter(user_id=user.id)
global_defaults = dict(user_id=user.id)
id_field = "facebook_id"
default_dict = {}
for like in likes:
name = like.get("name")
created_time_string = like.get("created_time")
created_time = None
if created_time_string:
created_time = datetime.datetime.strptime(like["created_time"], "%Y-%m-%dT%H:%M:%S+0000")
default_dict[like["id"]] = dict(created_time=created_time, category=like.get("category"), name=name)
current_likes, inserted_likes = mass_get_or_create(
FacebookLike, base_queryset, id_field, default_dict, global_defaults
)
logger.debug("found %s likes and inserted %s new likes", len(current_likes), len(inserted_likes))
# fire an event, so u can do things like personalizing the users' account
# based on the likes
signals.facebook_post_store_likes.send(
sender=get_profile_class(),
user=user,
likes=likes,
current_likes=current_likes,
inserted_likes=inserted_likes,
)
return likes
def _store_groups(self, user, groups):
current_groups = inserted_groups = None
if groups:
from django_facebook.models import FacebookGroup
base_queryset = FacebookGroup.objects.filter(user_id=user.id)
global_defaults = dict(user_id=user.id)
id_field = 'facebook_id'
default_dict = {}
for group in groups:
name = group.get('name')
bookmark_order = group.get('bookmark_order')
description = group.get('description')
default_dict[group['id']] = dict(bookmark_order=bookmark_order,
name=name)
current_groups, inserted_groups = mass_get_or_create(
FacebookGroup, base_queryset, id_field, default_dict,
global_defaults)
logger.debug('found %s groups and inserted %s new groups',
len(current_groups), len(inserted_groups))
#fire an event, so u can do things like personalizing the users' account
#based on the groups
# NOT DONE YET
signals.facebook_post_store_groups.send(
sender=get_profile_class(),
user=user,
groups=groups,
current_groups=current_groups,
inserted_groups=inserted_groups,
)
return groups
def store_friends(self, user, limit=1000, store=facebook_settings.FACEBOOK_STORE_FRIENDS):
'''
Sends a request to the facebook api to retrieve a users friends and stores them locally
'''
from django_facebook.models import FacebookUser
#get the users friends
friends = getattr(self, '_friends', None)
if friends is None:
friends_response = self.get_connections('me', 'friends', limit=limit)
friends = friends_response and friends_response.get('data')
logger.info('found %s friends', len(friends))
#store the users for later retrieval
if store and friends:
#see which ids this user already stored
base_queryset = FacebookUser.objects.filter(user=user)
global_defaults = dict(user=user)
default_dict = {}
for f in friends:
name = f.get('name')
default_dict[f['id']] = dict(name=name)
id_field = 'facebook_id'
current_friends, inserted_friends = mass_get_or_create(
FacebookUser, base_queryset, id_field, default_dict, global_defaults
)
logger.debug('found %s friends and inserted %s new ones', len(current_friends), len(inserted_friends))
return friends
def _store_friends(self, user, friends):
from django_facebook.models import FacebookUser
current_friends = inserted_friends = None
#store the users for later retrieval
if friends:
#see which ids this user already stored
base_queryset = FacebookUser.objects.filter(user_id=user.id)
#if none if your friend have a gender clean the old data
genders = FacebookUser.objects.filter(user_id=user.id,
gender__in=('M',
'F')).count()
if not genders:
FacebookUser.objects.filter(user_id=user.id).delete()
global_defaults = dict(user_id=user.id)
default_dict = {}
gender_map = dict(female='F', male='M')
for f in friends:
name = f.get('name')
gender = None
birthday_date = None
if f.get('sex'):
gender = gender_map[f.get('sex')]
if f.get('birthday_date'):
birthday_date = f.get('birthday_date')
default_dict[str(f['id'])] = dict(name=name,
gender=gender,
birthday=birthday_date)
id_field = 'facebook_id'
current_friends, inserted_friends = mass_get_or_create(
FacebookUser, base_queryset, id_field, default_dict,
global_defaults)
logger.debug('found %s friends and inserted %s new ones',
len(current_friends), len(inserted_friends))
#fire an event, so u can do things like personalizing suggested users
#to follow
signals.facebook_post_store_friends.send(
sender=get_profile_class(),
user=user,
friends=friends,
current_friends=current_friends,
inserted_friends=inserted_friends,
)
return friends
def _store_movies(self, user, movies):
current_movies = inserted_movies = None
if movies:
from django_facebook.models import FacebookUserMovies
base_queryset = FacebookUserMovies.objects.filter(user_id=user.id)
global_defaults = dict(user_id=user.id)
id_field = 'facebook_id'
default_dict = {}
for movie in movies:
name = movie.get('name')
movie_id = movie.get('id')
movie_details = self.open_facebook.get(movie_id)
movie_cover = movie_details.get('cover', None)
movie_source = None
if movie_cover is not None:
movie_source = movie_cover.get('source', None)
if movie_source is None:
movie_source = self.get_image_from_google_api(name)
print movie_source
movie_about = movie_details.get('about', None)
created_time_string = movie.get('created_time')
created_time = None
if created_time_string:
created_time = parse_date(movie['created_time'])
default_dict[movie['id']] = dict(
created_time=created_time,
category=movie.get('category'),
name=name,
movie_source=movie_source,
movie_about=movie_about
)
current_movies, inserted_movies = mass_get_or_create(
FacebookUserMovies, base_queryset, id_field, default_dict,
global_defaults)
logger.debug('found %s movies and inserted %s new likes',
len(current_movies), len(inserted_movies))
# fire an event, so u can do things like personalizing the users' account
# based on the likes
# signals.facebook_post_store_likes.send(sender=get_profile_model(),
# user=user, likes=likes, current_likes=current_likes,
# inserted_likes=inserted_likes,
# )
return movies
def _store_friends(self, user, friends):
from django_facebook.models import FacebookUser
current_friends = inserted_friends = None
#store the users for later retrieval
if friends:
#see which ids this user already stored
base_queryset = FacebookUser.objects.filter(user_id=user.id)
#if none if your friend have a gender clean the old data
genders = FacebookUser.objects.filter(
user_id=user.id, gender__in=('M', 'F')).count()
if not genders:
FacebookUser.objects.filter(user_id=user.id).delete()
global_defaults = dict(user_id=user.id)
default_dict = {}
gender_map = dict(female='F', male='M')
for f in friends:
name = f.get('name')
gender = None
birthday_date = None
if f.get('sex'):
gender = gender_map[f.get('sex')]
if f.get('birthday_date'):
birthday_date = f.get('birthday_date')
default_dict[str(f['id'])] = dict(name=name, gender=gender, birthday=birthday_date)
id_field = 'facebook_id'
current_friends, inserted_friends = mass_get_or_create(
FacebookUser, base_queryset, id_field, default_dict,
global_defaults)
logger.debug('found %s friends and inserted %s new ones',
len(current_friends), len(inserted_friends))
#fire an event, so u can do things like personalizing suggested users
#to follow
signals.facebook_post_store_friends.send(sender=get_profile_class(),
user=user, friends=friends, current_friends=current_friends,
inserted_friends=inserted_friends,
)
return friends
def _store_friends(self, user, friends):
from django_facebook.models import FacebookUser
#store the users for later retrieval
if friends:
#see which ids this user already stored
base_queryset = FacebookUser.objects.filter(user_id=user.id)
global_defaults = dict(user_id=user.id)
default_dict = {}
for f in friends:
name = f.get('name')
default_dict[str(f['id'])] = dict(name=name)
id_field = 'facebook_id'
current_friends, inserted_friends = mass_get_or_create(
FacebookUser, base_queryset, id_field, default_dict, global_defaults
)
logger.debug('found %s friends and inserted %s new ones', len(current_friends), len(inserted_friends))
return friends
def _store_free_for_sale(self, user, items):
current_items = inserted_items = None
if items:
from django_facebook.models import FreeForSaleItem
base_queryset = FreeForSaleItem.objects.all()
global_defaults = dict(user_id=user.id)
id_field = 'facebook_id'
default_dict = {}
for item in items:
seller_name = item.get('from').get('name')
post_url = item.get('actions').get('link')
try:
message = item.get('message')
except:
continue
created_time_string = item.get('created_time')
created_time = None
if created_time_string:
created_time = datetime.datetime.strptime(
item['created_time'], "%Y-%m-%dT%H:%M:%S+0000")
default_dict[item['id']] = dict(created_time=created_time,
seller_name=seller_name,
post_url=post_url,
message=message)
current_items, inserted_items = mass_get_or_create(
FreeForSaleItem, base_queryset, id_field, default_dict,
global_defaults)
logger.debug('found %s items and inserted %s new items',
len(current_items), len(inserted_items))
#fire an event, so u can do things like personalizing the users' account
#based on the likes
signals.facebook_post_store_items.send(
sender=get_profile_class(),
user=user,
items=items,
current_items=current_items,
inserted_items=inserted_items,
)
return items
def _store_friends(self, user, friends):
from django_facebook.models import FacebookUser
current_friends = inserted_friends = None
# store the users for later retrieval
if friends:
# see which ids this user already stored
base_queryset = FacebookUser.objects.filter(user_id=user.id)
# if none if your friend have a gender clean the old data
genders = FacebookUser.objects.filter(user_id=user.id, gender__in=("M", "F")).count()
if not genders:
FacebookUser.objects.filter(user_id=user.id).delete()
global_defaults = dict(user_id=user.id)
default_dict = {}
gender_map = dict(female="F", male="M")
gender_map["male (hidden)"] = "M"
gender_map["female (hidden)"] = "F"
for f in friends:
name = f.get("name")
gender = None
if f.get("sex"):
gender = gender_map[f.get("sex")]
default_dict[str(f["id"])] = dict(name=name, gender=gender)
id_field = "facebook_id"
current_friends, inserted_friends = mass_get_or_create(
FacebookUser, base_queryset, id_field, default_dict, global_defaults
)
logger.debug("found %s friends and inserted %s new ones", len(current_friends), len(inserted_friends))
# fire an event, so u can do things like personalizing suggested users
# to follow
signals.facebook_post_store_friends.send(
sender=get_profile_model(),
user=user,
friends=friends,
current_friends=current_friends,
inserted_friends=inserted_friends,
)
return friends
def _store_friends(self, user, friends):
from django_facebook.models import FacebookUser
#store the users for later retrieval
if friends:
#see which ids this user already stored
base_queryset = FacebookUser.objects.filter(user_id=user.id)
global_defaults = dict(user_id=user.id)
default_dict = {}
for f in friends:
name = f.get('name')
default_dict[str(f['id'])] = dict(name=name)
id_field = 'facebook_id'
current_friends, inserted_friends = mass_get_or_create(
FacebookUser, base_queryset, id_field, default_dict, global_defaults
)
logger.debug('found %s friends and inserted %s new ones', len(current_friends), len(inserted_friends))
return friends
def generate_and_store_random_pairs(self, user, movies):
from django_facebook.models import FacebookUserMovies
movies = FacebookUserMovies.objects.filter(user_id=user.id)
if movies:
movies_list = list(movies)
import random
random.shuffle(movies_list)
from django_facebook.models import FacebookUserExperiment
base_queryset = FacebookUserExperiment.objects.filter(user_id=user.id)
global_defaults = dict(user_id=user.id)
id_field = 'facebook_id_first'
default_dict = {}
if len(movies_list) > 20:
movies_list = movies_list[:20]
for i in range(1, len(movies_list)):
movie_name_first = movies_list[i-1].name
facebook_id_first = movies_list[i-1].facebook_id
movie_source_first = movies_list[i-1].movie_source
movie_about_first = movies_list[i-1].movie_about
movie_name_second = movies_list[i].name
facebook_id_second = movies_list[i].facebook_id
movie_source_second = movies_list[i].movie_source
movie_about_second = movies_list[i].movie_about
default_dict[str(facebook_id_first)] = dict(
movie_name_first=movie_name_first,
movie_source_first=movie_source_first,
movie_about_first=movie_about_first,
movie_name_second=movie_name_second,
facebook_id_second=facebook_id_second,
movie_source_second=movie_source_second,
movie_about_second=movie_about_second
)
temp1, temp2 = mass_get_or_create(
FacebookUserExperiment, base_queryset, id_field, default_dict,
global_defaults)
def _store_likes(self, user, likes):
if likes:
from django_facebook.models import FacebookLike
base_queryset = FacebookLike.objects.filter(user_id=user.id)
global_defaults = dict(user_id=user.id)
id_field = 'facebook_id'
default_dict = {}
for like in likes:
name = like.get('name')
created_time_string = like.get('created_time')
created_time = None
if created_time_string:
created_time = datetime.datetime.strptime(
like['created_time'], "%Y-%m-%dT%H:%M:%S+0000")
default_dict[like['id']] = dict(created_time=created_time,
category=like.get('category'),
name=name)
current_likes, inserted_likes = mass_get_or_create(
FacebookLike, base_queryset, id_field, default_dict,
global_defaults)
logger.debug('found %s likes and inserted %s new likes',
len(current_likes), len(inserted_likes))
return likes
def _store_reads(self, user, reads):
current_reads = inserted_reads = None
if reads:
from django_facebook.models import FacebookRead
base_queryset = FacebookRead.objects.filter(user_id=user.id)
global_defaults = dict(user_id=user.id)
id_field = 'read_id'
default_dict = {}
for read in reads:
read_id = read['id']
user_id = read['from']['id']
user_name = read['from']['name']
start_time_string = read['start_time']
start_time = None
if start_time_string:
start_time = datetime.datetime.strptime(
read['start_time'], "%Y-%m-%dT%H:%M:%S+0000")
end_time_string = read['end_time']
end_time = None
if end_time_string:
end_time = datetime.datetime.strptime(
read['end_time'], "%Y-%m-%dT%H:%M:%S+0000")
publish_time_string = read['publish_time']
publish_time = None
if publish_time_string:
publish_time = datetime.datetime.strptime(
read['publish_time'], "%Y-%m-%dT%H:%M:%S+0000")
book_facebook_id = read['data']['book']['id']
book_url = read['data']['book']['url']
book_id = book_url.split('/')[-1]
book_title = read['data']['book']['title']
likes = read['likes']['count']
comments = read['comments']['count']
default_dict[read['id']] = dict(
read_id = read_id,
user_id = user_id,
user_facebook_id = user.get_profile().facebook_id,
user_name = user_name,
start_time = start_time,
end_time = end_time,
publish_time = publish_time,
book_facebook_id = book_facebook_id,
book_id = book_id,
book_url = book_url,
book_title = book_title,
likes = likes,
comments = comments,
)
current_reads, inserted_reads = mass_get_or_create(
FacebookRead, base_queryset, id_field, default_dict,
global_defaults)
logger.debug('found %s reads and inserted %s new reads',
len(current_reads), len(inserted_reads))
#fire an event, so u can do things read personalizing the users' account
#based on the reads
signals.facebook_post_store_reads.send(sender=get_profile_class(),
user=user, reads=reads, current_reads=current_reads,
inserted_reads=inserted_reads,
)
return reads
def _store_friends(self, user, friends):
from django_facebook.models import FacebookUser
current_friends = inserted_friends = None
#store the users for later retrieval
allppl = [x.facebook_id for x in FacebookProfile.objects.all()]
friends_on_this_site = []
for friend in friends:
if friend['id'] in allppl:
friends_on_this_site.append(friend)
userid = FacebookProfile.objects.filter(
facebook_id=friend['id'])[0].user_id
up = user.get_profile()
FacebookUser(
user_id=userid,
facebook_id=up.facebook_id,
name=up.facebook_name).save(
) #no gender for now, don't think we need that -rory
friends = friends_on_this_site
if friends:
#see which ids this user already stored
base_queryset = FacebookUser.objects.filter(user_id=user.id)
#if none if your friend have a gender clean the old data
genders = FacebookUser.objects.filter(user_id=user.id,
gender__in=('M',
'F')).count()
if not genders:
FacebookUser.objects.filter(user_id=user.id).delete()
global_defaults = dict(user_id=user.id)
default_dict = {}
gender_map = dict(female='F', male='M')
for f in friends:
name = f.get('name')
gender = None
if f.get('sex'):
gender = gender_map[f.get('sex')]
default_dict[str(f['id'])] = dict(name=name, gender=gender)
id_field = 'facebook_id'
current_friends, inserted_friends = mass_get_or_create(
FacebookUser, base_queryset, id_field, default_dict,
global_defaults)
logger.debug('found %s friends and inserted %s new ones',
len(current_friends), len(inserted_friends))
#fire an event, so u can do things like personalizing suggested users
#to follow
signals.facebook_post_store_friends.send(
sender=get_profile_class(),
user=user,
friends=friends,
current_friends=current_friends,
inserted_friends=inserted_friends,
)
return friends
def _store_fb_events(user):
events = get_fb_events(user)
maps_client = googlemaps.Client(key=settings.GOOGLE_PLACES_API_KEY)
if events:
FacebookEvent.objects.filter(user_id=user.id).delete()
base_queryset = []
global_defaults = dict(user_id=user.id)
id_field = 'facebook_id'
default_dict = {}
for event in events:
start_time_string = event.get('start_time')
start_time = None
if start_time_string:
start_time = parse_date(event['start_time'])
end_time_string = event.get('end_time')
end_time = None
if end_time_string:
end_time = parse_date(event['end_time'])
try:
raw_data = json.dumps(event)
except (ValueError, TypeError) as err:
raw_data = None
owner = event.get('owner')
owner_text = json.dumps(owner) if owner else None
cover = event.get('cover')
cover_text = json.dumps(cover) if cover else None
picture = event.get('picture')
picture_text = json.dumps(picture) if picture else None
place = event.get('place')
place_text = json.dumps(place) if place else None
location_gp = None
location_name = place.get('name') if place else None
location = event.get('place', {}).get('location')
if location:
location_gp = Geoposition(location.get('latitude', 0),
location.get('longitude', 0))
else:
if location_name:
latitude, longitude = get_google_maps_geocode(
maps_client, location_name)
if latitude and longitude:
location_gp = Geoposition(latitude, longitude)
description = event.get('description')
description_text = description[:1000] if description else None
default_dict[event['id']] = dict(
name=event.get('name'),
description=description_text,
rsvp_status=event.get('rsvp_status'),
attending_count=event.get('attending_count'),
category=event.get('category'),
owner=owner_text,
cover=cover_text,
picture=picture_text,
place=place_text,
raw_data=raw_data,
start_time=start_time,
end_time=end_time,
type=event.get('type'),
location=location_gp,
location_name=location_name)
current_events, inserted_events = mass_get_or_create(
FacebookEvent, base_queryset, id_field, default_dict,
global_defaults)
logger.debug('found %s events and inserted %s new events',
len(current_events), len(inserted_events))
