def post(self, request, *args, **kwargs):
data = request.data
#create a new group given the name, description, and image
serializer = GroupSerializer(data=data)
if (serializer.is_valid(raise_exception=True)):
group_obj = Group(name=data.get('name'),
description=data.get('description'),
image=data.get('image'))
group_obj.save()
#associate the group with the owner and members through Membership
owner = request.user
if (not Membership.objects.filter(user=owner,
group=group_obj).exists()):
own_mem_obj = Membership(user=owner, group=group_obj, owner=True)
own_mem_obj.save()
members = data.get('members', '')
members = [item.strip() for item in members.strip().split(',')]
for member in members:
try:
user_obj = User.objects.get(email=member)
except User.DoesNotExists:
pass
if (not Membership.objects.filter(user=user_obj,
group=group_obj).exists()):
mem_obj = Membership(user=user_obj,
group=group_obj,
owner=False)
mem_obj.save()
#notify the group
msg_obj = BuddyMessage(user=user_obj,
group=group_obj,
message=''.join((user_obj.buddycode,
' joined the group')),
message_type=settings.MSG_TYPE_JOIN)
msg_obj.save()
#create an activity for the owner
if (not CreateGroup.objects.filter(user=owner,
group=group_obj).exists()):
activity_obj = CreateGroup(owner=owner,
group=group_obj,
longitude=owner.longitude,
latitude=owner.latitude)
activity_obj.save()
return Response({"success": True}, status=HTTP_200_OK)
def test_membership(self):
membership = Membership()
user = User.objects.create_user('Testy McTest', '*****@*****.**',
'testpassword')
user.save()
group = Group()
group.name = "Test Group"
group.save()
membership.user = User.objects.get(id=user.id)
membership.group = Group.objects.get(id=group.id)
membership.is_admin = False
membership.save()
test_membership = Membership.objects.get(id=membership.id)
self.assertEquals(test_membership, membership)
self.assertEquals(test_membership.user, User.objects.get(id=user.id))
self.assertEquals(test_membership.group,
Group.objects.get(id=group.id))
self.assertEquals(test_membership.is_admin, False)
membership.delete()
group.delete()
user.delete()
def post(self, request, *args, **kwargs):
data = request.data
user_to_email = data.get('user_email')
group_id = data.get('group_id')
user_from = request.user
#check if the user is part of the group
group_obj = Group.objects.get(id=group_id)
if (not Membership.objects.filter(user=user_from,
group=group_obj).exists()):
return Response(serializer.errors, status=HTTP_400_BAD_REQUEST)
#add user to group if the request user exists
try:
user_to_obj = User.objects.get(email=user_to_email)
mem_obj = Membership(user=user_to_obj,
group=group_obj,
owner=False)
mem_obj.save()
msg_obj = BuddyMessage(user=user_to_obj,
group=group_obj,
message=''.join((user_to_obj.buddycode,
' joined the group')),
message_type=settings.MSG_TYPE_JOIN)
msg_obj.save()
except User.DoesNotExists:
return Response(serializer.errors, status=HTTP_400_BAD_REQUEST)
#notify the group
return Response({"success": True}, status=HTTP_200_OK)
def setUp(self):
c1 = User.objects.create(
username='******', email='*****@*****.**', fullName='Admin')
g1 = Group.objects.create(
name='Cooldown', type="Organization", owner=c1, description="Test Group")
m1 = Membership(group=g1, member=c1, isOwner=True, isAssigner=True)
QuizCreate(c1, g1, "Test Quiz 1", "Quiz Description")
QuizCreate(c1, g1, "Test Quiz 2", "Hitchhiker's Guide")
q1 = Quiz.objects.get(pk=1)
q2 = Quiz.objects.get(pk=2)
ques1 = QuestionCreate(q1.pk)
ques2 = QuestionCreate(q2.pk)
def confirm_email_invite(request, key):
'''
Confirms an email invite to a specific user. This may or may not redirect
to a form for creating the new user (with first name, last name, and
password).
'''
key = key.lower()
user = EmailInvite.objects.confirm_email(key)
if user is not None:
# Handle the user case.
if not user.is_active:
'''
This may not be the best idea, but if the user is not active, then
activate them anyway, since this is just another link they'll have
to follow if they haven't already.
'''
user.is_active = True
# Check to see if they're already in the group, as this might not be the
# first time they've visited this link.
invite = EmailInvite.objects.get(confirmation_key=key)
group = invite.group
if not group.members.all().filter(email=user.email):
# change invite to show that user accepted
#invite.acceptance = 'A'
#invite.save()
invite.delete()
#
membership = Membership(user=user, group=group)
membership.save()
group.membership_set.add(membership) # user is now a member!
params = {
'group': group,
'user': user,
}
return render(request, 'invite_complete.html', params)
else:
# Handle the non-existing user case.
recipient_email = EmailInvite.objects.get_email(key)
if recipient_email is not None:
# The email is not none, so now we need to create a user.
# Redirect them to the form page for finishing their account.
#
# If they choose that they are an existing user, simply verify
# their credentials and then add them to the group, redirecting
# them to the inbox.
return redirect('/invite_registration/{0}'.format(key))
else:
return render(request, 'email_invite_error.html')
def invite_registration(request, key):
'''
Registers the user based on an their invitation.
'''
# If the email for this key doesn't exist, or there is a user already with
# the email, then whoever is here is here for the wrong reason. We'll (for
# now) just give them a 404.
email = EmailInvite.objects.get_email(key)
if email is None:
raise Http404
try:
user = User.objects.get(email=email)
except User.DoesNotExist:
user = None
if user is not None:
raise Http404
# If we're here, we have a user's email, which will be used for creating the
# user.
if request.method == 'POST':
form = InviteRegistrationForm(request.POST)
if form.is_valid():
'''
If the form is all good and such, then send the user off to the page
that'll say something like 'yay, you're registered with Bulletin!'
'''
user = form.save(email)
invite = EmailInvite.objects.get(confirmation_key=key)
# change invite to show that user accepted
#invite.acceptance = 'A'
#invite.save()
invite.delete()
#
group = invite.group
membership = Membership(user=user, group=group)
membership.save()
group.membership_set.add(membership)
group.save()
params = {
'group': group,
'user': user,
}
return render(request, 'invite_complete.html', params)
else:
form = InviteRegistrationForm()
ctx = {'form': form,
'action': '/invite_registration/{0}/'.format(key)}
return render(request, 'register.html', ctx)
from groups.models import Group, Membership, Request
from django.contrib.auth import User
#Delete all members
members = Membership.objects.all()
for member in members:
member.delete()
#Make fd, admin of group #11
user = User.objects.get(username=username)
group = Group.objects.get(id=11)
membership = Membership(user=user, group=group, admin=True)
membership.save()
#Make everyone but fd request to join group #11
users = User.objects.all()
for user in users:
if user.username is 'fd':
continue
request = Request(user=user, group=group)
request.save()
def save_group(request):
if not request.is_ajax():
return False
else:
# print request.POST
data = json.loads(request.POST['data'])
#print data['members']
#members = ast.literal_eval(data['members'][1])
#print type(members)
#print members['member_id']
# Check whether the group exists:
try:
group = get_object_or_404(Group, id=data['group_id'])
print group
except:
return HttpResponse('no such group')
# Iterate over the membership array
for datum in data['members']:
import ast
members = ast.literal_eval(datum)
member_id = members['member_id']
group_status = members['status']
print '>> Member {}: {}'.format(member_id,group_status)
if group_status != None or group_status != 'member':
# Check whether the member exists:
try:
print 'Finding member {}'.format(member_id)
member = get_object_or_404(Member, id=member_id)
print 'member {} found'.format(member)
except:
print 'member not found'
return HttpResponse('no such member')
# If we need to add the member...
if group_status == 'add-member':
print '>>> Add member!'
try:
membership = get_object_or_404(Membership, member=member, group=group)
return HttpResponse('member already exists')
except:
print '>> Create membership object!'
membership = Membership(member=member, group=group)
try:
print '>> Clean and save membership object!'
membership.clean()
membership.save()
except:
return HttpResponse('unable to save membership')
# If we need to remove the member...
elif group_status == 'remove-member':
print '>>> Remove member!'
try:
membership = get_object_or_404(Membership, member=member, group=group)
except:
print '>> No membership to remove. We\'re done!'
try:
membership.delete()
except:
return HttpResponse('unable to delete membership')
elif group_status == 'member':
print 'already a member...'
else:
print 'unknown group_status:'
print group_status
# All is done. Return a successful response to the template. :-)
return HttpResponse(json.dumps({ 'type': 'success' }))
def perform_create(self, serializer):
membership = Membership(**serializer.validated_data)
group_id = self.kwargs['pk']
membership.group = Group.objects.get(pk=group_id)
membership.save()
return MembershipSerializer(membership)
