def create(self, user_login_code, slug_name):
user = models.UserLogin.objects.get_user_by_code(user_login_code)
if not user:
raise EntityNotFound(f'User with code {user_login_code} not found')
group = models.Group.objects.get_group_by_group_slug_name(
user_login_code, slug_name)
if not group:
raise EntityNotFound(
f'Group with slug name {slug_name} not found.')
invitation = models.Invitation()
invitation.group = group
invitation.issued_by = user
invitation.status = Status.ACTIVE.value
membership = models.Membership.objects.get_membership_data_by_user_code_slug_name(
user_login_code, slug_name)
members_quantity = models.Membership.objects.get_membership_count_by_group_slug_name(
slug_name)
if membership.remaining_invitations == 0 or membership.status == 0 or membership.role == 1 or \
membership.group.members_limit < members_quantity:
raise UnAuthorized(
'You do not have remaining invitations or the privilege to invite or the group it is full'
)
new_invitation = models.Invitation.objecs.save(invitation)
membership.remaining_invitations -= 1
models.Membership.objects.save(membership)
return self.__mapped_detailed_invitation(new_invitation)
def update(self, login_user_code, slug_name, group_data):
user = models.UserLogin.objects.get_user_by_code(login_user_code)
if not user:
raise EntityNotFound(
f'User with code {login_user_code} not found'
)
group = models.Group.objects.get_group_by_group_slug_name(login_user_code, slug_name)
if not group:
raise EntityNotFound(
f'Group with slug name {slug_name} not found.'
)
role = models.Membership.objects.get_member_role_by_user_code_group_slug_name(login_user_code, slug_name)
for x in role:
print(x['role'])
if x['role'] != RoleLevel.OWNER.value:
raise UnAuthorized(
f'User with code {login_user_code} does not have the privileges to perform that action.'
)
group.name = group_data.get('name')
group.slug_name = group_data.get('slug_name')
group.about = group_data.get('about')
# if is_owner
group_saved = models.Group.objects.save(group)
return self.__mapped_group(group_saved)
def activate(self, invitation_code, request):
invitation = models.Invitation.objecs.get_invitation_by_code(
invitation_code)
if not invitation:
raise EntityNotFound(
f'Invitation with invitation code {invitation_code} not found')
if invitation.is_used:
raise UsedInvitation(
f'Invitation with code {invitation_code} has been used')
user_login_code = request.user['user_login_code']
invited_user = models.UserLogin.objects.get_user_by_code(
user_login_code)
if not invited_user:
raise EntityNotFound(f'User with code {user_login_code} not found')
# updating invitation
invitation.is_used = True
invitation.used_at = now()
invitation.used_by = invited_user
models.Invitation.objecs.save(invitation)
# creating new member
invitation_dict = self.__mapped_invitation(invitation)
issued_by = models.UserLogin.objects.get_user_by_code(
invitation_dict['issued_by'])
group = models.Group.objects.get_group_by_group_code(
invitation_dict['group_code'])
# update membership of issued_by
issued_by_membership = models.Membership.objects.get_membership_by_user_code_group_code(
invitation_dict['issued_by'], invitation_dict['group_code'])
print('50' * 50)
print(type(issued_by_membership))
print(issued_by_membership)
if issued_by_membership:
if issued_by_membership.remaining_invitations == 0:
raise MembersLimitExceeded(
'The user can have no longer invite')
issued_by_membership.used_invitations += 1
issued_by_membership.remaining_invitations -= 1
models.Membership.objects.save(issued_by_membership)
new_membership = models.Membership()
new_membership.group = group
new_membership.invited_by = issued_by
new_membership.user = invited_user
new_membership.role = RoleLevel.USER.value
new_membership.status = Status.ACTIVE.value
# Check member limits and if there is a duplicate member
member_limit = models.Membership.objects.get_membership_count_by_group_slug_name(
invitation_dict['group'])
if member_limit >= group.members_limit:
raise MembersLimitExceeded('Members limit exceeded.')
already_member = models.Membership.objects.get_membership_by_user_code_group_code(
user_login_code, invitation_dict['group_code'])
if already_member:
raise DuplicatedRecord('You already belong to this group.')
# Add new member
member_added = models.Membership.objects.save(new_membership)
return self.__mapped_membership(member_added)
def create(self, request, user_login_code, group_data):
"""
create function of group model
:param user_login_code: uuid
:param group_data: serialized data of group
:return: if no errors present does not raise exceptions.
"""
user = models.UserLogin.objects.get_user_by_code(user_login_code)
if not user:
raise EntityNotFound(
f'User with code {user_login_code} not found'
)
group_model = models.Group()
membership_model = models.Membership()
group_model.name = group_data.get('name')
group_model.slug_name = group_data.get('slug_name')
group_model.about = group_data.get('about')
group_model.status = Status.ACTIVE.value
saved_group = models.Group.objects.save(group_model)
membership_model.group = saved_group
membership_model.status = Status.ACTIVE.value
membership_model.role = RoleLevel.OWNER.value
membership_model.user = user
saved_membership = models.Membership.objects.save(membership_model)
def list(self, user_login_code, slug_name):
user = models.UserLogin.objects.get_user_by_code(user_login_code)
if not user:
raise EntityNotFound(f'User with code {user_login_code} not found')
group = models.Group.objects.get_group_by_group_slug_name(
user_login_code, slug_name)
if not group:
raise EntityNotFound(
f'Group with slug name {slug_name} not found.')
invitations = models.Invitation.objecs.get_all_Invitations(
user_login_code, slug_name)
invitations_list = []
for invitation in invitations:
invitations_list.append(
self.__mapped_detailed_invitation(invitation))
return invitations_list
def get_membership(self, user_login_code, slug_name):
user = models.UserLogin.objects.get_user_by_code(user_login_code)
if not user:
raise EntityNotFound(
f'User with code {user_login_code} not found.')
group = models.Group.objects.get_group_by_group_slug_name(
user_login_code, slug_name)
if not group:
raise EntityNotFound(f'Group with code {slug_name} not found.')
members = models.Membership.objects.get_all_members_by_slug_name(
slug_name)
members_list = []
if not members:
return []
for member in members:
members_list.append(self.__mapped_members(member))
return members_list
def retrieve(self, request, user_login_code, slug_name):
"""
retrive only one group,
:param user_login_code: uuid
:param slug_name: slug name of the group
:return: a dict with data of the selected group.
"""
user = models.UserLogin.objects.get_user_by_code(user_login_code)
if not user:
raise EntityNotFound(
f'User with code {user_login_code} not found.'
)
group = models.Group.objects.get_group_by_group_slug_name(user_login_code, slug_name)
if not group:
raise EntityNotFound(
f'Group with code {slug_name} not found.'
)
return self.__mapped_group_detailed(group)
def delete(self, request, login_user_code, slug_name):
user = models.UserLogin.objects.get_user_by_code(login_user_code)
if not user:
raise EntityNotFound(
f'User with code {login_user_code} not found'
)
group = models.Group.objects.get_group_by_group_slug_name(login_user_code, slug_name)
if not group:
raise EntityNotFound(
f'Group with slug name {slug_name} not found.'
)
role = models.Membership.objects.get_member_role_by_user_code_group_slug_name(login_user_code, slug_name)
for x in role:
print(x['role'])
if x['role'] != RoleLevel.OWNER.value:
raise UnAuthorized(
f'User with code {login_user_code} does not have the privileges to perform that action.'
)
models.Group.objects.delete(group)
def list(self, request, user_login_code):
"""
list user group by user code
:param user_login_code: uuid
:return: a list of dict with data of the group that the user it is part of.
"""
user = models.UserLogin.objects.get_user_by_code(user_login_code)
if not user:
raise EntityNotFound(
f'User with code {user_login_code} not found.'
)
groups = models.Group.objects.get_all_groups(user_login_code)
group_list = []
for group in groups:
group_list.append(self.__mapped_group(group))
return group_list
def authenticate(self, username, password):
try:
return self.get_queryset().authenticate(username, password)
except models.ObjectDoesNotExist:
raise EntityNotFound('User was not found')