Mathis/allianceauth
1
0
Fork 0
mirror of https://gitlab.com/allianceauth/allianceauth.git synced 2025-07-13 22:40:16 +02:00
Code Issues Packages Projects Releases Wiki Activity

reverted code formatting for Aaron :-)

Browse Source
This commit is contained in:
Peter Pfeufer 2020-10-26 01:06:58 +01:00
parent 4c42153bfd
commit 6cd0a42791
No known key found for this signature in database
GPG Key ID: 6051D2C6AD4EBC27
2 changed files with 169 additions and 372 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

88
allianceauth/groupmanagement/models.py
View File

@ -55,6 +55,7 @@ class RequestLog(models.Model):
return user.profile.main_character return user.profile.main_character
class AuthGroup(models.Model): class AuthGroup(models.Model):
""" """
Extends Django Group model with a one-to-one field Extends Django Group model with a one-to-one field
@ -75,75 +76,46 @@ class AuthGroup(models.Model):
Open - Users are automatically accepted into the group Open - Users are automatically accepted into the group
Not Open - Users requests must be approved before they are added to the group Not Open - Users requests must be approved before they are added to the group
""" """
group = models.OneToOneField(Group, on_delete=models.CASCADE, primary_key=True) group = models.OneToOneField(Group, on_delete=models.CASCADE, primary_key=True)
internal = models.BooleanField( internal = models.BooleanField(default=True,
default=True, help_text="Internal group, users cannot see, join or request to join this group.<br>"
help_text="Internal group, users cannot see, join or request to join this group.<br>" "Used for groups such as Members, Corp_*, Alliance_* etc.<br>"
"Used for groups such as Members, Corp_*, Alliance_* etc.<br>" "<b>Overrides Hidden and Open options when selected.</b>")
"<b>Overrides Hidden and Open options when selected.</b>", hidden = models.BooleanField(default=True,
) help_text="Group is hidden from users but can still join with the correct link.")
open = models.BooleanField(default=False,
hidden = models.BooleanField( help_text="Group is open and users will be automatically added upon request. <br>"
default=True, "If the group is not open users will need their request manually approved.")
help_text="Group is hidden from users but can still join with the correct link.", public = models.BooleanField(default=False,
) help_text="Group is public. Any registered user is able to join this group, with "
"visibility based on the other options set for this group.<br> Auth will "
open = models.BooleanField( "not remove users from this group automatically when they are no longer "
default=False, "authenticated.")
help_text="Group is open and users will be automatically added upon request. <br>"
"If the group is not open users will need their request manually approved.",
)
public = models.BooleanField(
default=False,
help_text="Group is public. Any registered user is able to join this group, with "
"visibility based on the other options set for this group.<br> Auth will "
"not remove users from this group automatically when they are no longer "
"authenticated.",
)
# Group leaders have management access to this group # Group leaders have management access to this group
group_leaders = models.ManyToManyField( group_leaders = models.ManyToManyField(User, related_name='leads_groups', blank=True,
User, help_text="Group leaders can process group requests for this group "
related_name="leads_groups", "specifically. Use the auth.group_management permission to allow "
blank=True, "a user to manage all groups.")
help_text="Group leaders can process group requests for this group "
"specifically. Use the auth.group_management permission to allow "
"a user to manage all groups.",
)
# allow groups to be *group leads* # allow groups to be *group leads*
group_leader_groups = models.ManyToManyField( group_leader_groups = models.ManyToManyField(Group, related_name='leads_group_groups', blank=True,
Group, help_text="Group leaders can process group requests for this group "
related_name="leads_group_groups", "specifically. Use the auth.group_management permission to allow "
blank=True, "a user to manage all groups.")
help_text="Group leaders can process group requests for this group "
"specifically. Use the auth.group_management permission to allow "
"a user to manage all groups.",
)
states = models.ManyToManyField( states = models.ManyToManyField(State, related_name='valid_states', blank=True,
State, help_text="States listed here will have the ability to join this group provided "
related_name="valid_states", "they have the proper permissions.")
blank=True,
help_text="States listed here will have the ability to join this group provided "
"they have the proper permissions.",
)
description = models.TextField( description = models.TextField(max_length=512, blank=True, help_text="Short description <i>(max. 512 characters)</i> of the group shown to users.")
max_length=512,
null=True,
blank=True,
help_text="Short description <i>(max. 512 characters)</i> of the group shown to users.",
)
def __str__(self): def __str__(self):
return self.group.name return self.group.name
class Meta: class Meta:
permissions = (("request_groups", u"Can request non-public groups"),) permissions = (
("request_groups", u"Can request non-public groups"),
)
default_permissions = tuple() default_permissions = tuple()

453
allianceauth/groupmanagement/views.py
View File

@ -27,9 +27,7 @@ def group_management(request):
acceptrequests = [] acceptrequests = []
leaverequests = [] leaverequests = []
base_group_query = GroupRequest.objects.select_related( base_group_query = GroupRequest.objects.select_related('user', 'group', 'user__profile__main_character')
"user", "group", "user__profile__main_character"
)
if GroupManager.has_management_permission(request.user): if GroupManager.has_management_permission(request.user):
# Full access # Full access
group_requests = base_group_query.all() group_requests = base_group_query.all()
@ -44,14 +42,12 @@ def group_management(request):
else: else:
acceptrequests.append(grouprequest) acceptrequests.append(grouprequest)
logger.debug( logger.debug("Providing user %s with %s acceptrequests and %s leaverequests." % (
"Providing user %s with %s acceptrequests and %s leaverequests." request.user, len(acceptrequests), len(leaverequests)))
% (request.user, len(acceptrequests), len(leaverequests))
)
render_items = {"acceptrequests": acceptrequests, "leaverequests": leaverequests} render_items = {'acceptrequests': acceptrequests, 'leaverequests': leaverequests}
return render(request, "groupmanagement/index.html", context=render_items) return render(request, 'groupmanagement/index.html', context=render_items)
@login_required @login_required
@ -66,15 +62,11 @@ def group_membership(request):
# Group leader specific # Group leader specific
groups = GroupManager.get_group_leaders_groups(request.user) groups = GroupManager.get_group_leaders_groups(request.user)
groups = ( groups = groups.exclude(authgroup__internal=True).annotate(num_members=Count('user')).order_by('name')
groups.exclude(authgroup__internal=True)
.annotate(num_members=Count("user"))
.order_by("name")
)
render_items = {"groups": groups} render_items = {'groups': groups}
return render(request, "groupmanagement/groupmembership.html", context=render_items) return render(request, 'groupmanagement/groupmembership.html', context=render_items)
@login_required @login_required
@ -85,22 +77,18 @@ def group_membership_audit(request, group_id):
try: try:
# Check its a joinable group i.e. not corp or internal # Check its a joinable group i.e. not corp or internal
# And the user has permission to manage it # And the user has permission to manage it
if not GroupManager.check_internal_group( if not GroupManager.check_internal_group(group) or not GroupManager.can_manage_group(request.user, group):
group logger.warning("User %s attempted to view the membership of group %s but permission was denied" %
) or not GroupManager.can_manage_group(request.user, group): (request.user, group_id))
logger.warning(
"User %s attempted to view the membership of group %s but permission was denied"
% (request.user, group_id)
)
raise PermissionDenied raise PermissionDenied
except ObjectDoesNotExist: except ObjectDoesNotExist:
raise Http404("Group does not exist") raise Http404("Group does not exist")
render_items = {"group": group.name} render_items = {'group': group.name}
entries = RequestLog.objects.filter(group=group).order_by("-date") entries = RequestLog.objects.filter(group=group).order_by('-date')
render_items["entries"] = entries render_items['entries'] = entries
return render(request, "groupmanagement/audit.html", context=render_items) return render(request, 'groupmanagement/audit.html', context=render_items)
@login_required @login_required
@ -115,9 +103,9 @@ def group_membership_list(request, group_id):
# Check its a joinable group i.e. not corp or internal # Check its a joinable group i.e. not corp or internal
# And the user has permission to manage it # And the user has permission to manage it
if not GroupManager.check_internal_group( if (not GroupManager.check_internal_group(group)
group or not GroupManager.can_manage_group(request.user, group)
) or not GroupManager.can_manage_group(request.user, group): ):
logger.warning( logger.warning(
"User %s attempted to view the membership of group %s " "User %s attempted to view the membership of group %s "
"but permission was denied" % (request.user, group_id) "but permission was denied" % (request.user, group_id)
@ -129,136 +117,90 @@ def group_membership_list(request, group_id):
group_leaders = group.authgroup.group_leaders.all() group_leaders = group.authgroup.group_leaders.all()
members = list() members = list()
for member in ( for member in \
group.user_set.all() group.user_set\
.select_related("profile", "profile__main_character") .all()\
.order_by("profile__main_character__character_name") .select_related('profile', 'profile__main_character')\
): .order_by('profile__main_character__character_name'):
members.append( members.append({
{ 'user': member,
"user": member, 'main_char': member.profile.main_character,
"main_char": member.profile.main_character, 'is_leader': member in group_leaders
"is_leader": member in group_leaders, })
}
)
render_items = {"group": group, "members": members} render_items = {'group': group, 'members': members}
return render(request, "groupmanagement/groupmembers.html", context=render_items) return render(
request, 'groupmanagement/groupmembers.html',
context=render_items
)
@login_required @login_required
@user_passes_test(GroupManager.can_manage_groups) @user_passes_test(GroupManager.can_manage_groups)
def group_membership_remove(request, group_id, user_id): def group_membership_remove(request, group_id, user_id):
logger.debug( logger.debug("group_membership_remove called by user %s for group id %s on user id %s" %
"group_membership_remove called by user %s for group id %s on user id %s" (request.user, group_id, user_id))
% (request.user, group_id, user_id)
)
group = get_object_or_404(Group, id=group_id) group = get_object_or_404(Group, id=group_id)
try: try:
# Check its a joinable group i.e. not corp or internal # Check its a joinable group i.e. not corp or internal
# And the user has permission to manage it # And the user has permission to manage it
if not GroupManager.check_internal_group( if not GroupManager.check_internal_group(group) or not GroupManager.can_manage_group(request.user, group):
group logger.warning("User %s attempted to remove a user from group %s but permission was denied" % (request.user,
) or not GroupManager.can_manage_group(request.user, group): group_id))
logger.warning(
"User %s attempted to remove a user from group %s but permission was denied"
% (request.user, group_id)
)
raise PermissionDenied raise PermissionDenied
try: try:
user = group.user_set.get(id=user_id) user = group.user_set.get(id=user_id)
request_info = user.username + ":" + group.name request_info = user.username + ":" + group.name
log = RequestLog( log = RequestLog(request_type=None,group=group,request_info=request_info,action=1,request_actor=request.user)
request_type=None,
group=group,
request_info=request_info,
action=1,
request_actor=request.user,
)
log.save() log.save()
# Remove group from user # Remove group from user
user.groups.remove(group) user.groups.remove(group)
logger.info( logger.info("User %s removed user %s from group %s" % (request.user, user, group))
"User %s removed user %s from group %s" % (request.user, user, group) messages.success(request, _("Removed user %(user)s from group %(group)s.") % {"user": user, "group": group})
)
messages.success(
request,
_("Removed user %(user)s from group %(group)s.")
% {"user": user, "group": group},
)
except ObjectDoesNotExist: except ObjectDoesNotExist:
messages.warning(request, _("User does not exist in that group")) messages.warning(request, _("User does not exist in that group"))
except ObjectDoesNotExist: except ObjectDoesNotExist:
messages.warning(request, _("Group does not exist")) messages.warning(request, _("Group does not exist"))
return redirect("groupmanagement:membership", group_id) return redirect('groupmanagement:membership', group_id)
@login_required @login_required
@user_passes_test(GroupManager.can_manage_groups) @user_passes_test(GroupManager.can_manage_groups)
def group_accept_request(request, group_request_id): def group_accept_request(request, group_request_id):
logger.debug( logger.debug("group_accept_request called by user %s for grouprequest id %s" % (request.user, group_request_id))
"group_accept_request called by user %s for grouprequest id %s"
% (request.user, group_request_id)
)
group_request = get_object_or_404(GroupRequest, id=group_request_id) group_request = get_object_or_404(GroupRequest, id=group_request_id)
try: try:
group, created = Group.objects.get_or_create(name=group_request.group.name) group, created = Group.objects.get_or_create(name=group_request.group.name)
if not GroupManager.joinable_group( if not GroupManager.joinable_group(group_request.group, group_request.user.profile.state) or \
group_request.group, group_request.user.profile.state not GroupManager.can_manage_group(request.user, group_request.group):
) or not GroupManager.can_manage_group(request.user, group_request.group):
raise PermissionDenied raise PermissionDenied
group_request.user.groups.add(group) group_request.user.groups.add(group)
group_request.user.save() group_request.user.save()
log = RequestLog( log = RequestLog(request_type=group_request.leave_request,group=group,request_info=group_request.__str__(),action=1,request_actor=request.user)
request_type=group_request.leave_request,
group=group,
request_info=group_request.__str__(),
action=1,
request_actor=request.user,
)
log.save() log.save()
group_request.delete() group_request.delete()
logger.info( logger.info("User %s accepted group request from user %s to group %s" % (
"User %s accepted group request from user %s to group %s" request.user, group_request.user, group_request.group.name))
% (request.user, group_request.user, group_request.group.name) notify(group_request.user, "Group Application Accepted", level="success",
) message="Your application to %s has been accepted." % group_request.group)
notify( messages.success(request,
group_request.user, _('Accepted application from %(mainchar)s to %(group)s.') % {"mainchar": group_request.main_char, "group": group_request.group})
"Group Application Accepted",
level="success",
message="Your application to %s has been accepted." % group_request.group,
)
messages.success(
request,
_("Accepted application from %(mainchar)s to %(group)s.")
% {"mainchar": group_request.main_char, "group": group_request.group},
)
except PermissionDenied as p: except PermissionDenied as p:
logger.warning( logger.warning("User %s attempted to accept group join request %s but permission was denied" %
"User %s attempted to accept group join request %s but permission was denied" (request.user, group_request_id))
% (request.user, group_request_id)
)
raise p raise p
except: except:
messages.error( messages.error(request, _('An unhandled error occurred while processing the application from %(mainchar)s to %(group)s.') % {"mainchar": group_request.main_char, "group": group_request.group})
request, logger.exception("Unhandled exception occurred while user %s attempting to accept grouprequest id %s." % (
_( request.user, group_request_id))
"An unhandled error occurred while processing the application from %(mainchar)s to %(group)s."
)
% {"mainchar": group_request.main_char, "group": group_request.group},
)
logger.exception(
"Unhandled exception occurred while user %s attempting to accept grouprequest id %s."
% (request.user, group_request_id)
)
pass pass
return redirect("groupmanagement:management") return redirect("groupmanagement:management")
@ -267,60 +209,31 @@ def group_accept_request(request, group_request_id):
@login_required @login_required
@user_passes_test(GroupManager.can_manage_groups) @user_passes_test(GroupManager.can_manage_groups)
def group_reject_request(request, group_request_id): def group_reject_request(request, group_request_id):
logger.debug( logger.debug("group_reject_request called by user %s for group request id %s" % (request.user, group_request_id))
"group_reject_request called by user %s for group request id %s"
% (request.user, group_request_id)
)
group_request = get_object_or_404(GroupRequest, id=group_request_id) group_request = get_object_or_404(GroupRequest, id=group_request_id)
try: try:
if not GroupManager.can_manage_group(request.user, group_request.group): if not GroupManager.can_manage_group(request.user, group_request.group):
raise PermissionDenied raise PermissionDenied
if group_request: if group_request:
logger.info( logger.info("User %s rejected group request from user %s to group %s" % (
"User %s rejected group request from user %s to group %s" request.user, group_request.user, group_request.group.name))
% (request.user, group_request.user, group_request.group.name) log = RequestLog(request_type=group_request.leave_request,group=group_request.group,request_info=group_request.__str__(),action=0,request_actor=request.user)
)
log = RequestLog(
request_type=group_request.leave_request,
group=group_request.group,
request_info=group_request.__str__(),
action=0,
request_actor=request.user,
)
log.save() log.save()
group_request.delete() group_request.delete()
notify( notify(group_request.user, "Group Application Rejected", level="danger",
group_request.user, message="Your application to %s has been rejected." % group_request.group)
"Group Application Rejected", messages.success(request,
level="danger", _('Rejected application from %(mainchar)s to %(group)s.') % {"mainchar": group_request.main_char, "group": group_request.group})
message="Your application to %s has been rejected."
% group_request.group,
)
messages.success(
request,
_("Rejected application from %(mainchar)s to %(group)s.")
% {"mainchar": group_request.main_char, "group": group_request.group},
)
except PermissionDenied as p: except PermissionDenied as p:
logger.warning( logger.warning("User %s attempted to reject group join request %s but permission was denied" %
"User %s attempted to reject group join request %s but permission was denied" (request.user, group_request_id))
% (request.user, group_request_id)
)
raise p raise p
except: except:
messages.error( messages.error(request, _('An unhandled error occurred while processing the application from %(mainchar)s to %(group)s.') % {"mainchar": group_request.main_char, "group": group_request.group})
request, logger.exception("Unhandled exception occurred while user %s attempting to reject group request id %s" % (
_( request.user, group_request_id))
"An unhandled error occurred while processing the application from %(mainchar)s to %(group)s."
)
% {"mainchar": group_request.main_char, "group": group_request.group},
)
logger.exception(
"Unhandled exception occurred while user %s attempting to reject group request id %s"
% (request.user, group_request_id)
)
pass pass
return redirect("groupmanagement:management") return redirect("groupmanagement:management")
@ -330,9 +243,7 @@ def group_reject_request(request, group_request_id):
@user_passes_test(GroupManager.can_manage_groups) @user_passes_test(GroupManager.can_manage_groups)
def group_leave_accept_request(request, group_request_id): def group_leave_accept_request(request, group_request_id):
logger.debug( logger.debug(
"group_leave_accept_request called by user %s for group request id %s" "group_leave_accept_request called by user %s for group request id %s" % (request.user, group_request_id))
% (request.user, group_request_id)
)
group_request = get_object_or_404(GroupRequest, id=group_request_id) group_request = get_object_or_404(GroupRequest, id=group_request_id)
try: try:
if not GroupManager.can_manage_group(request.user, group_request.group): if not GroupManager.can_manage_group(request.user, group_request.group):
@ -341,48 +252,24 @@ def group_leave_accept_request(request, group_request_id):
group, created = Group.objects.get_or_create(name=group_request.group.name) group, created = Group.objects.get_or_create(name=group_request.group.name)
group_request.user.groups.remove(group) group_request.user.groups.remove(group)
group_request.user.save() group_request.user.save()
log = RequestLog( log = RequestLog(request_type=group_request.leave_request,group=group_request.group,request_info=group_request.__str__(),action=1,request_actor=request.user)
request_type=group_request.leave_request,
group=group_request.group,
request_info=group_request.__str__(),
action=1,
request_actor=request.user,
)
log.save() log.save()
group_request.delete() group_request.delete()
logger.info( logger.info("User %s accepted group leave request from user %s to group %s" % (
"User %s accepted group leave request from user %s to group %s" request.user, group_request.user, group_request.group.name))
% (request.user, group_request.user, group_request.group.name) notify(group_request.user, "Group Leave Request Accepted", level="success",
) message="Your request to leave %s has been accepted." % group_request.group)
notify( messages.success(request,
group_request.user, _('Accepted application from %(mainchar)s to leave %(group)s.') % {"mainchar": group_request.main_char, "group": group_request.group})
"Group Leave Request Accepted",
level="success",
message="Your request to leave %s has been accepted." % group_request.group,
)
messages.success(
request,
_("Accepted application from %(mainchar)s to leave %(group)s.")
% {"mainchar": group_request.main_char, "group": group_request.group},
)
except PermissionDenied as p: except PermissionDenied as p:
logger.warning( logger.warning("User %s attempted to accept group leave request %s but permission was denied" %
"User %s attempted to accept group leave request %s but permission was denied" (request.user, group_request_id))
% (request.user, group_request_id)
)
raise p raise p
except: except:
messages.error( messages.error(request, _('An unhandled error occurred while processing the application from %(mainchar)s to leave %(group)s.') % {
request, "mainchar": group_request.main_char, "group": group_request.group})
_( logger.exception("Unhandled exception occurred while user %s attempting to accept group leave request id %s" % (
"An unhandled error occurred while processing the application from %(mainchar)s to leave %(group)s." request.user, group_request_id))
)
% {"mainchar": group_request.main_char, "group": group_request.group},
)
logger.exception(
"Unhandled exception occurred while user %s attempting to accept group leave request id %s"
% (request.user, group_request_id)
)
pass pass
return redirect("groupmanagement:management") return redirect("groupmanagement:management")
@ -392,58 +279,31 @@ def group_leave_accept_request(request, group_request_id):
@user_passes_test(GroupManager.can_manage_groups) @user_passes_test(GroupManager.can_manage_groups)
def group_leave_reject_request(request, group_request_id): def group_leave_reject_request(request, group_request_id):
logger.debug( logger.debug(
"group_leave_reject_request called by user %s for group request id %s" "group_leave_reject_request called by user %s for group request id %s" % (request.user, group_request_id))
% (request.user, group_request_id)
)
group_request = get_object_or_404(GroupRequest, id=group_request_id) group_request = get_object_or_404(GroupRequest, id=group_request_id)
try: try:
if not GroupManager.can_manage_group(request.user, group_request.group): if not GroupManager.can_manage_group(request.user, group_request.group):
raise PermissionDenied raise PermissionDenied
if group_request: if group_request:
log = RequestLog( log = RequestLog(request_type=group_request.leave_request,group=group_request.group,request_info=group_request.__str__(),action=0,request_actor=request.user)
request_type=group_request.leave_request,
group=group_request.group,
request_info=group_request.__str__(),
action=0,
request_actor=request.user,
)
log.save() log.save()
group_request.delete() group_request.delete()
logger.info( logger.info("User %s rejected group leave request from user %s for group %s" % (
"User %s rejected group leave request from user %s for group %s" request.user, group_request.user, group_request.group.name))
% (request.user, group_request.user, group_request.group.name) notify(group_request.user, "Group Leave Request Rejected", level="danger",
) message="Your request to leave %s has been rejected." % group_request.group)
notify( messages.success(request, _('Rejected application from %(mainchar)s to leave %(group)s.') % {
group_request.user, "mainchar": group_request.main_char, "group": group_request.group})
"Group Leave Request Rejected",
level="danger",
message="Your request to leave %s has been rejected."
% group_request.group,
)
messages.success(
request,
_("Rejected application from %(mainchar)s to leave %(group)s.")
% {"mainchar": group_request.main_char, "group": group_request.group},
)
except PermissionDenied as p: except PermissionDenied as p:
logger.warning( logger.warning("User %s attempted to reject group leave request %s but permission was denied" %
"User %s attempted to reject group leave request %s but permission was denied" (request.user, group_request_id))
% (request.user, group_request_id)
)
raise p raise p
except: except:
messages.error( messages.error(request, _('An unhandled error occurred while processing the application from %(mainchar)s to leave %(group)s.') % {
request, "mainchar": group_request.main_char, "group": group_request.group})
_( logger.exception("Unhandled exception occurred while user %s attempting to reject group leave request id %s" % (
"An unhandled error occurred while processing the application from %(mainchar)s to leave %(group)s." request.user, group_request_id))
)
% {"mainchar": group_request.main_char, "group": group_request.group},
)
logger.exception(
"Unhandled exception occurred while user %s attempting to reject group leave request id %s"
% (request.user, group_request_id)
)
pass pass
return redirect("groupmanagement:management") return redirect("groupmanagement:management")
@ -456,131 +316,96 @@ def groups_view(request):
groups_qs = GroupManager.get_joinable_groups_for_user( groups_qs = GroupManager.get_joinable_groups_for_user(
request.user, include_hidden=False request.user, include_hidden=False
) )
groups_qs = groups_qs.order_by("name") groups_qs = groups_qs.order_by('name')
groups = [] groups = []
for group in groups_qs: for group in groups_qs:
group_request = GroupRequest.objects.filter(user=request.user).filter( group_request = GroupRequest.objects\
group=group .filter(user=request.user)\
) .filter(group=group)
groups.append( groups.append({
{"group": group, "request": group_request[0] if group_request else None} 'group': group,
) 'request': group_request[0] if group_request else None
})
context = {"groups": groups} context = {'groups': groups}
return render(request, "groupmanagement/groups.html", context=context) return render(request, 'groupmanagement/groups.html', context=context)
@login_required @login_required
def group_request_add(request, group_id): def group_request_add(request, group_id):
logger.debug( logger.debug("group_request_add called by user %s for group id %s" % (request.user, group_id))
"group_request_add called by user %s for group id %s" % (request.user, group_id)
)
group = Group.objects.get(id=group_id) group = Group.objects.get(id=group_id)
state = request.user.profile.state state = request.user.profile.state
if not GroupManager.joinable_group(group, state): if not GroupManager.joinable_group(group, state):
logger.warning( logger.warning("User %s attempted to join group id %s but it is not a joinable group" %
"User %s attempted to join group id %s but it is not a joinable group" (request.user, group_id))
% (request.user, group_id)
)
messages.warning(request, _("You cannot join that group")) messages.warning(request, _("You cannot join that group"))
return redirect("groupmanagement:groups") return redirect('groupmanagement:groups')
if group in request.user.groups.all(): if group in request.user.groups.all():
# User is already a member of this group. # User is already a member of this group.
logger.warning( logger.warning("User %s attempted to join group id %s but they are already a member." %
"User %s attempted to join group id %s but they are already a member." (request.user, group_id))
% (request.user, group_id)
)
messages.warning(request, _("You are already a member of that group.")) messages.warning(request, _("You are already a member of that group."))
return redirect("groupmanagement:groups") return redirect('groupmanagement:groups')
if ( if not request.user.has_perm('groupmanagement.request_groups') and not group.authgroup.public:
not request.user.has_perm("groupmanagement.request_groups")
and not group.authgroup.public
):
# Does not have the required permission, trying to join a non-public group # Does not have the required permission, trying to join a non-public group
logger.warning( logger.warning("User %s attempted to join group id %s but it is not a public group" %
"User %s attempted to join group id %s but it is not a public group" (request.user, group_id))
% (request.user, group_id)
)
messages.warning(request, _("You cannot join that group")) messages.warning(request, _("You cannot join that group"))
return redirect("groupmanagement:groups") return redirect('groupmanagement:groups')
if group.authgroup.open: if group.authgroup.open:
logger.info("%s joining %s as is an open group" % (request.user, group)) logger.info("%s joining %s as is an open group" % (request.user, group))
request.user.groups.add(group) request.user.groups.add(group)
return redirect("groupmanagement:groups") return redirect("groupmanagement:groups")
req = GroupRequest.objects.filter(user=request.user, group=group) req = GroupRequest.objects.filter(user=request.user, group=group)
if len(req) > 0: if len(req) > 0:
logger.info( logger.info("%s attempted to join %s but already has an open application" % (request.user, group))
"%s attempted to join %s but already has an open application" messages.warning(request, _("You already have a pending application for that group."))
% (request.user, group)
)
messages.warning(
request, _("You already have a pending application for that group.")
)
return redirect("groupmanagement:groups") return redirect("groupmanagement:groups")
grouprequest = GroupRequest() grouprequest = GroupRequest()
grouprequest.status = _("Pending") grouprequest.status = _('Pending')
grouprequest.group = group grouprequest.group = group
grouprequest.user = request.user grouprequest.user = request.user
grouprequest.leave_request = False grouprequest.leave_request = False
grouprequest.save() grouprequest.save()
logger.info( logger.info("Created group request for user %s to group %s" % (request.user, Group.objects.get(id=group_id)))
"Created group request for user %s to group %s" messages.success(request, _('Applied to group %(group)s.') % {"group": group})
% (request.user, Group.objects.get(id=group_id))
)
messages.success(request, _("Applied to group %(group)s.") % {"group": group})
return redirect("groupmanagement:groups") return redirect("groupmanagement:groups")
@login_required @login_required
def group_request_leave(request, group_id): def group_request_leave(request, group_id):
logger.debug( logger.debug("group_request_leave called by user %s for group id %s" % (request.user, group_id))
"group_request_leave called by user %s for group id %s"
% (request.user, group_id)
)
group = Group.objects.get(id=group_id) group = Group.objects.get(id=group_id)
if not GroupManager.check_internal_group(group): if not GroupManager.check_internal_group(group):
logger.warning( logger.warning("User %s attempted to leave group id %s but it is not a joinable group" %
"User %s attempted to leave group id %s but it is not a joinable group" (request.user, group_id))
% (request.user, group_id)
)
messages.warning(request, _("You cannot leave that group")) messages.warning(request, _("You cannot leave that group"))
return redirect("groupmanagement:groups") return redirect('groupmanagement:groups')
if group not in request.user.groups.all(): if group not in request.user.groups.all():
logger.debug( logger.debug("User %s attempted to leave group id %s but they are not a member" %
"User %s attempted to leave group id %s but they are not a member" (request.user, group_id))
% (request.user, group_id)
)
messages.warning(request, _("You are not a member of that group")) messages.warning(request, _("You are not a member of that group"))
return redirect("groupmanagement:groups") return redirect('groupmanagement:groups')
if group.authgroup.open: if group.authgroup.open:
logger.info("%s leaving %s as is an open group" % (request.user, group)) logger.info("%s leaving %s as is an open group" % (request.user, group))
request.user.groups.remove(group) request.user.groups.remove(group)
return redirect("groupmanagement:groups") return redirect("groupmanagement:groups")
req = GroupRequest.objects.filter(user=request.user, group=group) req = GroupRequest.objects.filter(user=request.user, group=group)
if len(req) > 0: if len(req) > 0:
logger.info( logger.info("%s attempted to leave %s but already has an pending leave request." % (request.user, group))
"%s attempted to leave %s but already has an pending leave request." messages.warning(request, _("You already have a pending leave request for that group."))
% (request.user, group)
)
messages.warning(
request, _("You already have a pending leave request for that group.")
)
return redirect("groupmanagement:groups") return redirect("groupmanagement:groups")
if getattr(settings, "AUTO_LEAVE", False): if getattr(settings, 'AUTO_LEAVE', False):
logger.info( logger.info("%s leaving joinable group %s due to auto_leave" % (request.user, group))
"%s leaving joinable group %s due to auto_leave" % (request.user, group)
)
request.user.groups.remove(group) request.user.groups.remove(group)
return redirect("groupmanagement:groups") return redirect('groupmanagement:groups')
grouprequest = GroupRequest() grouprequest = GroupRequest()
grouprequest.status = _("Pending") grouprequest.status = _('Pending')
grouprequest.group = group grouprequest.group = group
grouprequest.user = request.user grouprequest.user = request.user
grouprequest.leave_request = True grouprequest.leave_request = True
grouprequest.save() grouprequest.save()
logger.info( logger.info("Created group leave request for user %s to group %s" % (request.user, Group.objects.get(id=group_id)))
"Created group leave request for user %s to group %s" messages.success(request, _('Applied to leave group %(group)s.') % {"group": group})
% (request.user, Group.objects.get(id=group_id))
)
messages.success(request, _("Applied to leave group %(group)s.") % {"group": group})
return redirect("groupmanagement:groups") return redirect("groupmanagement:groups")