def unfriend(self, user1, user2):
'''
Remove user2 from user1's friends
'''
Debug.say('ENTERED')
# Break friendship link between users
Friendship.objects.get(
user=user1
).friends.remove(
Friendship.objects.get(
user=user2
)
)
# Delete FriendshipRequest's as well
FriendshipRequest.objects.filter(
from_user=user1,
to_user=user2
).delete()
FriendshipRequest.objects.filter(
from_user=user2,
to_user=user1
).delete()
Debug.say('FINISHED')
def call_testing_code(self):
# prepare environ
app_settings.USE_USER_ID_INSTEAD_USERNAME = False
Debug.set_level(0)
self.client.get(reverse('friends-friendship-request', args=('user2',)))
Debug.set_level(0)
def action(self, request, user, **kwargs):
Debug.say('ENTERED')
other_user = user
self.accept_friendship(other_user, request.user)
Debug.say('FINISHED')
def call_testing_code(self):
# prepare environ
app_settings.USE_USER_ID_INSTEAD_USERNAME = True
Debug.set_level(0)
self.client.get(reverse("friends-friendship-delete", args=(self.user2.id,)))
Debug.set_level(0)
def accept_friendship(self, from_user, to_user):
Debug.say('ENTERED from_user = {0}, to_user = {1}'.format(from_user, to_user))
get_object_or_404(
FriendshipRequest,
from_user=from_user,
to_user=to_user
).accept()
Friendship.objects.befriend(to_user, from_user)
FriendshipRequest.objects.filter(
from_user=to_user,
to_user=from_user
).delete()
messages.info(
request=self.request,
message= Strings.BECOME_FREINDS % {
'user': from_user.get_full_name() or from_user.username
}
)
#TODO send email
Debug.say('FINISHED')
def create_friendship_instance(sender, instance, created, raw, **kwargs):
Debug.say('ENTERED')
from friends.models import Friendship
if created and not raw:
Friendship.objects.create(user=instance)
Debug.say('FINISHED')
def call_testing_code(self):
# prepare environ
app_settings.USE_USER_ID_INSTEAD_USERNAME = False
Debug.set_level(100)
response = self.client.get(reverse("friends-list", args=("user1",)), {"page": 2})
Debug.set_level(0)
return response
def call_testing_code(self):
# prepare environ
app_settings.USE_USER_ID_INSTEAD_USERNAME = True
Debug.set_level(0)
response = self.client.get(reverse("friends-list", args=(self.user1.id,)))
Debug.set_level(0)
return response
def cancel(self):
'''
Cancel own friendship request
'''
Debug.say('ENTERED')
signals.friendship_request_canceled.send(sender=self)
self.delete()
Debug.say('FINISHED')
def decline(self):
'''
Decline friendship request
'''
Debug.say('ENTERED')
signals.friendship_request_declined.send(sender=self)
self.delete()
Debug.say('FINISHED')
def accept(self):
'''
Accept friendship request
'''
Debug.say('ENTERED')
self.accepted = True
self.save()
signals.friendship_request_accepted.send(sender=self)
Debug.say('FINISHED')
def friends_of(self, user, shuffle=False):
'''
Fetch friends
'''
Debug.say('ENTERED')
qs = User.objects.filter(friendship__friends__user=user)
if shuffle:
qs = qs.order_by('?')
Debug.say('FINISHED')
return qs
def __init__(self, target_user, current_user='******',
template_name='friends/tags/add_to_friends.html'):
Debug.say('''ENTERED
target_user = {0}
current_user = {1}
'''.format(target_user, current_user)
)
self.target_user = template.Variable(target_user)
self.current_user = template.Variable(current_user)
self.template_name = template_name
Debug.say('FINISHED')
def are_friends(self, user1, user2):
'''
Check that two users are freinds
'''
Debug.say('ENTERED')
result = Friendship.objects.get(
user=user1
).friends.filter(
user=user2
).exists()
Debug.say('FINISHED result = {0}'.format(result))
return result
def befriend(self, user1, user2):
'''
Make friendship relationship
'''
Debug.say('ENTERED')
Friendship.objects.get(
user=user1
).friends.add(
Friendship.objects.get(
user=user2
)
)
Debug.say('FINISHED')
def render(self, context):
Debug.say('ENTERED')
target_user = self.target_user.resolve(context)
current_user = self.current_user.resolve(context)
Debug.say('''VAARS
target_user = {0}
current_user = {1}
'''.format(target_user, current_user),
100
)
if current_user.is_authenticated():
ctx = {
'target_user': target_user,
'current_user': current_user
}
if not target_user is current_user:
ctx['are_friends'] = Friendship.objects.are_friends(
target_user,
current_user
)
ctx['is_invited'] = bool(
FriendshipRequest.objects.filter(
from_user=current_user,
to_user=target_user,
accepted=False
).count()
)
ctx['is_invitee'] = bool(
FriendshipRequest.objects.filter(
from_user=target_user,
to_user=current_user,
accepted=False
).count()
)
return template.loader.render_to_string(
self.template_name,
ctx,
context
)
else:
return u''
def action(self, request, user, **kwargs):
Debug.say('ENTERED')
other_user = user
get_object_or_404(
FriendshipRequest,
from_user=request.user,
to_user=other_user
).cancel()
messages.info(
self.request,
message = Strings.REQUEST_CANCELED % {
'user': other_user.get_full_name() or other_user.username
}
)
Debug.say('FINISHED')
def action(self, request, user, **kwargs):
Debug.say('ENTERED')
other_user = user
if Friendship.objects.are_friends(request.user, other_user) is False:
raise Http404(
Strings.NOT_FRIENDS_YET % (other_user.get_full_name() or other_user.username,)
)
Friendship.objects.unfriend(request.user, other_user)
messages.info(
self.request,
message=Strings.NOT_FRIENDS_ALREADY % {
'user': other_user.get_full_name() or other_user.username
}
)
Debug.say('FINISHED')
def create_friendship_instance_post_syncdb(sender,
app,
created_models,
verbosity,
**kwargs):
Debug.say('ENTERED')
from django.contrib.auth.models import User
from friends.models import Friendship
created = 0
print "Creating friendships"
for user in User.objects.filter(friendship__isnull=True):
Friendship.objects.create(user=user)
created += 1
if verbosity >= 2:
print "Friendship created for %s" % user
if verbosity >= 1:
print "%d friendships created" % created
Debug.say('FINISHED')
def action(self, request, user, **kwargs):
Debug.say('ENTERED')
other_user = user
if Friendship.objects.are_friends(request.user, other_user):
messages.create(
message = Strings.ALREADY_FRIENDS % {
'user': other_user.get_full_name() or other_user.username
}
)
raise RuntimeError
try:
# Check if the other user have already requested friendship
self.accept_friendship(other_user, request.user)
except Http404:
pass
request_message = request.REQUEST.get('message', u'')
try:
FriendshipRequest.objects.create(
from_user=request.user,
to_user=other_user,
message=request_message
)
except IntegrityError:
transaction.rollback()
message = Strings.ALREADY_ACTIVATED
else:
message = Strings.REQUEST_SENT
messages.info(
self.request,
message=message % {
'user': other_user.get_full_name() or other_user.username
}
)
Debug.say('FINISHED')
def action(self, request, user, **kwargs):
Debug.say('ENTERED')
other_user = user
get_object_or_404(
FriendshipRequest,
from_user=other_user,
to_user=request.user
).decline()
FriendshipRequest.objects.filter(
from_user=request.user,
to_user=other_user
).delete()
messages.info(
self.request,
message = Strings.DECLINE_COMPLETE% {
'user': other_user.get_full_name() or other_user.username
}
)
Debug.say('FINISHED')
def get(self, request, *args, **kwargs):
Debug.say('ENTERED kwargs = {0}'.format(kwargs))
if app_settings.USE_USER_ID_INSTEAD_USERNAME:
Debug.say('Working through USERID. userid = {userid}'.format(**kwargs), 100)
if request.user.id == kwargs['userid']:
return HttpResponseBadRequest(Strings.CANT_BE_FRIENDS_YOURSELF)
user = get_object_or_404(User, id=kwargs['userid'])
else:
Debug.say('Working through USERNAME. username = {username}'.format(**kwargs), 100)
if request.user.username == kwargs['username']:
return HttpResponseBadRequest(Strings.CANT_BE_FRIENDS_YOURSELF)
user = get_object_or_404(User, username=kwargs['username'])
self.action(request, user, *args, **kwargs)
self.set_url(request, **kwargs)
Debug.say('FINISHED')
return super(BaseFriendshipActionView, self).get(request, **kwargs)
def friend_list(request, username=None, userid=None, paginate_by=None, page=None,
allow_empty=True, template_name='friends/friends_list.html',
extra_context={}, template_object_name='friends'):
'''
Show friends list
'''
Debug.say('''ENTERED
- username = {username}
- userid = {userid}
- paginate_by = {paginate_by}
- page = {page}
- allow_empty = {allow_empty}
- template_name = {template_name}
- username = {username}
- extra_context = {extra_context}
- template_object_name = {template_object_name}
'''.format(
username = username,
userid = userid,
paginate_by = paginate_by,
page = page,
allow_empty = allow_empty,
template_name = template_name,
extra_context = extra_context,
template_object_name = template_object_name
))
if username:
user = get_object_or_404(User, username=username)
elif userid:
user = get_object_or_404(User, id=userid)
else:
user = request.user
friends = Friendship.objects.friends_of(user)
incoming_requests = FriendshipRequest.objects.filter(
to_user=request.user,
accepted=False
)
outgoing_requests = FriendshipRequest.objects.filter(
from_user=request.user,
accepted=False
)
extra_context['target_user'] = user
extra_context['friendship_requests'] = {
'incoming': incoming_requests,
'outgoing': outgoing_requests,
}
extra_context['profile'] = request.user.profile
if 'mode' in request.GET and request.GET.get('mode') in ('incoming', 'sending', 'home'):
extra_context['mode'] = request.GET.get('mode')
else:
extra_context['mode'] = 'home'
Debug.say('FINISHED')
return object_list(
request,
queryset=friends,
paginate_by=paginate_by,
page=page,
allow_empty=allow_empty,
template_name=template_name,
extra_context=extra_context,
template_object_name=template_object_name
)
