def send(self, graph=None, shared_explicitly=False):
result = None
# update the last attempt
self.last_attempt = datetime.now()
self.save()
# see if the graph is enabled
profile = try_get_profile(self.user)
user_or_profile = get_instance_for_attribute(
self.user, profile, 'access_token')
graph = graph or user_or_profile.get_offline_graph()
user_enabled = shared_explicitly or \
(user_or_profile.facebook_open_graph and self.facebook_user_id)
# start sharing
if graph and user_enabled:
graph_location = '%s/%s' % (
self.facebook_user_id, self.action_domain)
share_dict = self.get_share_dict()
from open_facebook.exceptions import OpenFacebookException
try:
result = graph.set(graph_location, **share_dict)
share_id = result.get('id')
if not share_id:
error_message = 'No id in Facebook response, found %s for url %s with data %s' % (
result, graph_location, share_dict)
logging.error(error_message)
raise OpenFacebookException(error_message)
self.share_id = share_id
self.error_message = None
self.completed_at = datetime.now()
self.save()
except OpenFacebookException as e:
logging.warn(
'Open graph share failed, writing message %s' % str(e))
self.error_message = repr(e)
self.save()
# maybe we need a new access token
new_token_required = self.exception_requires_new_token(
e, graph)
# verify that the token didnt change in the mean time
user_or_profile = user_or_profile.__class__.objects.get(
id=user_or_profile.id)
token_changed = graph.access_token != user_or_profile.access_token
logging.info('new token required is %s and token_changed is %s',
new_token_required, token_changed)
if new_token_required and not token_changed:
logging.info(
'a new token is required, setting the flag on the user or profile')
# time to ask the user for a new token
update_user_attributes(self.user, profile, dict(
new_token_required=True), save=True)
elif not graph:
self.error_message = 'no graph available'
self.save()
elif not user_enabled:
self.error_message = 'user not enabled'
self.save()
return result
def send(self, graph=None):
result = None
#update the last attempt
self.last_attempt = datetime.now()
self.save()
#see if the graph is enabled
profile = self.user.get_profile()
graph = graph or profile.get_offline_graph()
user_enabled = profile.facebook_open_graph and self.facebook_user_id
#start sharing
if graph and user_enabled:
graph_location = '%s/%s' % (self.facebook_user_id,
self.action_domain)
share_dict = self.get_share_dict()
from open_facebook.exceptions import OpenFacebookException
try:
result = graph.set(graph_location, **share_dict)
share_id = result.get('id')
if not share_id:
error_message = 'No id in Facebook response, found %s for url %s with data %s' % (
result, graph_location, share_dict)
logger.error(error_message)
raise OpenFacebookException(error_message)
self.share_id = share_id
self.error_message = None
self.completed_at = datetime.now()
self.save()
except OpenFacebookException, e:
logger.warn('Open graph share failed, writing message %s' %
e.message)
self.error_message = unicode(e)
self.save()
def send(self, graph=None):
result = None
#update the last attempt
self.last_attempt = datetime.now()
self.save()
#see if the graph is enabled
profile = self.user.get_profile()
graph = graph or profile.get_offline_graph()
user_enabled = profile.facebook_open_graph and self.facebook_user_id
#start sharing
if graph and user_enabled:
graph_location = '%s/%s' % (
self.facebook_user_id, self.action_domain)
share_dict = self.get_share_dict()
from open_facebook.exceptions import OpenFacebookException
try:
result = graph.set(graph_location, **share_dict)
share_id = result.get('id')
if not share_id:
error_message = 'No id in Facebook response, found %s for url %s with data %s' % (result, graph_location, share_dict)
logger.error(error_message)
raise OpenFacebookException(error_message)
self.share_id = share_id
self.error_message = None
self.completed_at = datetime.now()
self.save()
except OpenFacebookException, e:
logger.warn(
'Open graph share failed, writing message %s' % e.message)
self.error_message = unicode(e)
self.save()
def send(self, graph=None, shared_explicitly=False):
result = None
# update the last attempt
self.last_attempt = datetime.now()
self.save()
# see if the graph is enabled
profile = try_get_profile(self.user)
user_or_profile = get_instance_for_attribute(
self.user, profile, 'access_token')
graph = graph or user_or_profile.get_offline_graph()
user_enabled = shared_explicitly or \
(user_or_profile.facebook_open_graph and self.facebook_user_id)
# start sharing
if graph and user_enabled:
graph_location = '%s/%s' % (
self.facebook_user_id, self.action_domain)
share_dict = self.get_share_dict()
from open_facebook.exceptions import OpenFacebookException
try:
result = graph.set(graph_location, **share_dict)
share_id = result.get('id')
if not share_id:
error_message = 'No id in Facebook response, found %s for url %s with data %s' % (
result, graph_location, share_dict)
logger.error(error_message)
raise OpenFacebookException(error_message)
self.share_id = share_id
self.error_message = None
self.completed_at = datetime.now()
self.save()
except OpenFacebookException as e:
logger.warn(
'Open graph share failed, writing message %s' % str(e))
self.error_message = repr(e)
self.save()
# maybe we need a new access token
new_token_required = self.exception_requires_new_token(
e, graph)
# verify that the token didnt change in the mean time
user_or_profile = user_or_profile.__class__.objects.get(
id=user_or_profile.id)
token_changed = graph.access_token != user_or_profile.access_token
logger.info('new token required is %s and token_changed is %s',
new_token_required, token_changed)
if new_token_required and not token_changed:
logger.info(
'a new token is required, setting the flag on the user or profile')
# time to ask the user for a new token
update_user_attributes(self.user, profile, dict(
new_token_required=True), save=True)
elif not graph:
self.error_message = 'no graph available'
self.save()
elif not user_enabled:
self.error_message = 'user not enabled'
self.save()
return result
def recently_failed(self):
from django_facebook import settings as facebook_settings
now = datetime.now()
recent_delta = timedelta(
days=facebook_settings.FACEBOOK_OG_SHARE_RETRY_DAYS)
recent = now - recent_delta
failed = self.failed()
recently_failed = failed.filter(created_at__gte=recent)
return recently_failed
def recently_failed(self):
from django_facebook import settings as facebook_settings
now = datetime.now()
recent_delta = timedelta(
days=facebook_settings.FACEBOOK_OG_SHARE_RETRY_DAYS)
recent = now - recent_delta
failed = self.failed()
recently_failed = failed.filter(created_at__gte=recent)
return recently_failed
def post_on_profile(user, fb, facebook_id, invite_message, force_class=None, force_send=False, raise_=False):
'''
Utility function for posting on a users profile.
Stores the invite in a FacebookInvite model so we can
- get statistics
- retry later if the invite failed
'''
facebook_classes = [BaseFacebookInvite]
class_dict = dict([(f.type, f) for f in facebook_classes])
from django_facebook.models import FacebookInvite
wallpost_id = None
try:
fb_invite, created = FacebookInvite.objects.get_or_create(
user=user, user_invited=facebook_id, defaults=dict(message=invite_message))
fb_invite.last_attempt = datetime.now()
modulo = fb_invite.id % len(facebook_classes)
message_class = facebook_classes[modulo]
if force_class:
message_class = class_dict[force_class]
if created or force_send:
# set a different type per style of the message and add custom if
# there is a custom invite message
fb_invite.type = message_class.get_type(invite_message)
fb_invite.save()
message_instance = message_class()
wallpost_response = message_instance.set_message(
user, fb, facebook_id, invite_message)
wallpost_id = wallpost_response.get('id')
logger.info(
'wrote message %s to user %s', invite_message, facebook_id)
fb_invite.error = False
fb_invite.error_message = None
fb_invite.save()
else:
logger.info(
'we are not sending email at the moment cause the invite already existed')
except facebook_exceptions.OpenFacebookException as e:
logger.warn(str(e), exc_info=sys.exc_info(), extra={
'data': {
'user': user,
'message': invite_message,
'facebook_user': facebook_id,
'body': str(e),
}
})
fb_invite.error = True
fb_invite.error_message = str(e)
fb_invite.save()
if raise_:
raise
fb_invite.wallpost_id = wallpost_id
fb_invite.save()
return fb_invite
def remove(self, graph=None):
if not self.share_id:
raise ValueError('Can only delete shares which have an id')
#see if the graph is enabled
profile = self.user.get_profile()
graph = graph or profile.get_offline_graph()
response = graph.delete(self.share_id)
self.removed_at = datetime.now()
self.save()
def remove(self, graph=None):
if not self.share_id:
raise ValueError('Can only delete shares which have an id')
# see if the graph is enabled
profile = try_get_profile(self.user)
graph = graph or profile.get_offline_graph()
response = None
if graph:
response = graph.delete(self.share_id)
self.removed_at = datetime.now()
self.save()
return response
def remove(self, graph=None):
if not self.share_id:
raise ValueError('Can only delete shares which have an id')
# see if the graph is enabled
profile = try_get_profile(self.user)
user_or_profile = get_instance_for_attribute(
self.user, profile, 'access_token')
graph = graph or user_or_profile.get_offline_graph()
response = None
if graph:
response = graph.delete(self.share_id)
self.removed_at = datetime.now()
self.save()
return response
def post_on_profile(user,
fb,
facebook_id,
invite_message,
force_class=None,
force_send=False,
raise_=False):
'''
Utility function for posting on a users profile.
Stores the invite in a FacebookInvite model so we can
- get statistics
- retry later if the invite failed
'''
facebook_classes = [BaseFacebookInvite]
class_dict = dict([(f.type, f) for f in facebook_classes])
from django_facebook.models import FacebookInvite
wallpost_id = None
try:
fb_invite, created = FacebookInvite.objects.get_or_create(
user=user,
user_invited=facebook_id,
defaults=dict(message=invite_message))
fb_invite.last_attempt = datetime.now()
modulo = fb_invite.id % len(facebook_classes)
message_class = facebook_classes[modulo]
if force_class:
message_class = class_dict[force_class]
if created or force_send:
# set a different type per style of the message and add custom if
# there is a custom invite message
fb_invite.type = message_class.get_type(invite_message)
fb_invite.save()
message_instance = message_class()
wallpost_response = message_instance.set_message(
user, fb, facebook_id, invite_message)
wallpost_id = wallpost_response.get('id')
logger.info('wrote message %s to user %s', invite_message,
facebook_id)
fb_invite.error = False
fb_invite.error_message = None
fb_invite.save()
else:
logger.info(
'we are not sending email at the moment cause the invite already existed'
)
except facebook_exceptions.OpenFacebookException, e:
logger.warn(unicode(e),
exc_info=sys.exc_info(),
extra={
'data': {
'user': user,
'message': invite_message,
'facebook_user': facebook_id,
'body': unicode(e),
}
})
fb_invite.error = True
fb_invite.error_message = unicode(e)
fb_invite.save()
if raise_:
raise
