def accept(self, user):
"""Update invitation status when invitation ia accepted"""
# If invitation is to a group, assign user to that group
# See if user is already a member of this group
try:
# If so, member is probably being promoted to 'coordinator'
membership = Membership.objects.get(user=user, group=self.group)
except:
membership = None
if membership:
return
else:
membership = Membership(user=user,
group=self.group,
date_joined=datetime.datetime.now(),
is_coordinator=False)
# Add link from user to group
user.groups.add(self.group.id)
user.save()
membership.save()
multi_use_invitation_user = MultiUseInvitationUsers(
multi_use_invitation=self, group=self.group, user=user)
multi_use_invitation_user.save()
self.save()
def form_valid(self, form):
"""Create a Membership between the creator user and the new Group."""
response = super().form_valid(form)
membership = Membership(user=self.request.user,
group=form.instance,
role=GroupRole.objects.get(name="Admin"))
membership.save()
return response
def post(self, request, *args, **kwargs):
print(self.kwargs.get('pk'))
if Group.objects.get(id=self.kwargs.get('pk')):
m1 = Membership(person=request.user,
group=Group.objects.get(id=self.kwargs.get('pk')),
date_joined=today())
m1.save()
return redirect('groups')
def create_project(request):
if request.method == 'POST':
form = ProjectCreateForm(request.POST)
if form.is_valid():
form.save()
p = get_object_or_404(Project,name=request.POST['name'], leader=request.user)
membership = Membership(user=request.user, project=p)
membership.save()
projects = Project.objects.filter(name='Prototype', leader__username='******', methodology__pk=request.POST['methodology'],
enabled=True)
if projects.count() == 1:
project = projects.get()
activities = Activity.objects.filter(project=project)
for activity in activities:
pk_activity = activity.pk
activity.pk = None
activity.date_start = timezone.now()
activity.date_end = timezone.now()
activity.project = p
activity_aux = get_object_or_404(Activity,pk=pk_activity)
activity.save()
activity.activities_required = activity_aux.activities_required.all()
activity.activities_super = activity_aux.activities_super.all()
activity.save()
activities = Activity.objects.filter(project=p)
for activity in activities:
activities_required = activity.activities_required.all()
activities_clone_required = []
for activity_required in activities_required:
activities_clone_required.append(get_object_or_404(Activity, name=activity_required.name, project=p))
activities_super = activity.activities_super.all()
activities_clone_super = []
for activity_super in activities_required:
activities_clone_super.append(get_object_or_404(Activity, name=activity_super.name, project=p))
activity.activities_required = activities_clone_required
activity.activities_super = activities_clone_super
activity.save()
return manage_project(request)
else:
# m = Methodology.objects.filter(is_private=True, enabled=True)
form = ProjectCreateForm(initial={'leader':request.user})
return render_to_response('project/create_project.html', {'form':form,}, context_instance=RequestContext(request))
def create_user_role_form(request, user_id):
Usuario = User.objects.get(id=user_id)
Roles = Role.objects.all()
if str(Usuario) in request.GET:
message = 'Se ha agregado nuevo rol al usuario %r' % str(Usuario)
new_rol = Membership(user_id=user_id,
project_id=1,
role_id=int(request.GET[str(Usuario)]),
date_joined='2012-07-01')
new_rol.save()
else:
message = 'No se envio su formulario'
return render_to_response('activity/create_user_role.html', {
'message': message,
'Usuario': Usuario,
'Roles': Roles
},
context_instance=RequestContext(request))
def my_join_request(request):
if request.method == 'POST':
r = get_object_or_404(Request,to_user_id=request.user.id, project_id = request.POST['project'])
message = ""
if(request.POST['button'] == 'accept'):
p = get_object_or_404(Project,pk=request.POST['project'])
membership = Membership(user=request.user, project=p)
membership.save()
message = "La solicitud ha sido aceptada"
else:
message = "La solicitud ha sido rechazada"
r.delete()
return render_to_response('social/my_join_request.html',
{'message':message},
context_instance=RequestContext(request))
else:
join_request = Request.objects.filter(to_user_id=request.user.id)
return render_to_response('social/my_join_request.html',
{'join_request':join_request},
context_instance=RequestContext(request))
def CreateGroup(request):
auth_user = CheckAuth(request)
if auth_user == False:
return HttpResponse(status=403)
name = request.POST.get('name', False)
users_group = request.POST.get('users', False)
user_admin = User.objects.get(init=auth_user[0]['id'])
#### CREATE GROUP #####
init = get_random_string(length=32)
key = get_random_string(length=32)
try:
insert = Group(init=init,
admin=user_admin.id,
name=name,
date_create=datetime.now(),
public_key=key)
insert.save()
except IntegrityError as e:
return HttpResponse('{"status":"error","reason":"name exist"}')
#### /CREATE GROUP #####
users_in_group = User.objects.filter(init__in=users_group.split(','))
a = list(users_in_group)
for i in users_in_group:
usr = User.objects.get(id=i.id)
usr.group.add(insert.id)
insert_membership = Membership(group=init)
insert_membership.save()
member = Membership.objects.get(group=init)
member.users.add(*a)
return HttpResponse('{"status":"success","init":"' + init + '","name":"' +
name + '"}')
def accept_invitation(request, pk):
"""View for accepting an invitation and creating a membership."""
invitation = Invitation.objects.get(pk=pk)
membership_role = GroupRole.objects.get(name="Member")
if not Membership.objects.filter(user=request.user,
group=invitation.group).exists():
Membership(user=request.user,
group=invitation.group,
role=membership_role).save()
emails = EmailAddress.objects.filter(user=request.user)
Invitation.objects.filter(email__in=emails.values('email'),
group=invitation.group).delete()
return HttpResponse()
def post(self, request, *args, **kwargs):
# memb = Membership.objects.get(person=request.user, group_id = self.kwargs.get('pk') )
try:
memb = Membership.objects.get(person=request.user, group_id=self.kwargs.get('pk'))
except:
memb = None
if not memb:
if Group.objects.get(id=self.kwargs.get('pk')):
m1 = Membership(person=request.user, group=Group.objects.get(id=self.kwargs.get('pk')), date_joined=today())
m1.save()
else:
m1 = Membership.objects.get(person=request.user, group=Group.objects.get(id=self.kwargs.get('pk')))
m1.delete()
return redirect('groups')
def accept(self, user):
"""Update invitation status when invitation ia accepted"""
# If invitation is to a group, assign user to that group
if (self.invitation_type == Invitation.BECOME_GROUP_MEMBER or
self.invitation_type == Invitation.BECOME_GROUP_COORDINATOR):
if self.invitation_type != Invitation.BECOME_GROUP_MEMBER:
is_coordinator = True
else:
is_coordinator = False
# See if user is already a member of this group
try:
# If so, member is probably being promoted to 'coordinator'
membership = Membership.objects.get(user=user,
group=self.group)
except:
membership = None
if membership:
if is_coordinator and not membership.is_coordinator:
# promote user to coordinator
if membership.is_active:
sc = StatusChange(user=user,
group=self.group,
status_change=status_change_values[
'MEMBER_TO_ADMIN'],
is_initiated_by_user=False)
sc.save()
membership.is_coordinator = is_coordinator
membership.save()
elif membership.is_removed:
membership.is_active = True
membership.is_removed = False
membership.date_became_removed = None
user.groups.add(self.group.id)
user.save()
membership.save()
print(membership.is_removed)
else:
print("Duplicate Invitation not caught")
raise
else:
membership = Membership(user=user,
group=self.group,
date_joined=datetime.datetime.now(),
is_coordinator=is_coordinator)
# Add link from user to group
user.groups.add(self.group.id)
user.save()
membership.save()
self.is_accepted = True
self.response_timestamp = timezone.now()
self.confirmed_invitee = user
self.save()
# Since user is now registered, delete record as UnregisteredUser
invitee = self.invitee
invitee.delete()
def done(self, form_list, form_dict, **kwargs):
"""
Gather the data from the three forms. If the user already exists,
update the profile, if not create a new user. Then add a new membership.
"""
login_step = self.get_cleaned_data_for_step('login')
address_step = self.get_cleaned_data_for_step('user_info')['address']
profile_step = self.get_cleaned_data_for_step('user_info')['profile']
membership_step = self.get_cleaned_data_for_step('membership')
# Renew membership for current user
if login_step is None:
u = self.request.user
# Update the user profile
profile_form = ProfileForm(profile_step, instance=u.profile)
u.profile = profile_form.save()
u.save()
else:
# Create a new user from steps 'login' & 'profile'
u = User(email=login_step['email'])
u.is_active = False # Not activated yet
p = Profile(**profile_step)
p.save()
u.profile = p
u.save()
# Create or update address info
addresses = u.profile.address_set.all()
if len(addresses) > 0:
add = addresses[0]
add = AddressForm(address_step, instance=addresses[0])
else:
add = Address(**address_step)
add.profile = u.profile
add.save()
# Create a new Membership object
membership = Membership(**membership_step)
membership.profile = u.profile
membership.start_date = membership.next_start_date()
membership.amount = membership.compute_amount()
membership.duration = 1 # valid for one year
membership.save()
# Send a confirmation email if the user has to pay
if membership.amount > 0:
membership.email_user(status="submitted")
mb_url = self.request.build_absolute_uri(
reverse('membership-detail', args=[membership.uid]))
return redirect("membership-detail", membership.uid)