def del_group(group):
group = get_group(group)
from pylons import tmpl_context as c
for member in [member_role.member for member_role in group.members_roles]:
member.send_notification(
messages.group_deleted(group=group, admin=c.logged_in_user)
) # AllanC - We cant use the standard group.send_notification because the group wont exisit after this line!
Session.delete(group)
Session.commit()
def set_role(group, member, role, delay_commit=False):
group = get_group(group)
member = get_member(member)
membership = get_membership(group, member)
role = role or membership.role or group.default_role
if not group:
raise action_error(_('unable to find group'), code=404)
if not member:
raise action_error(_('unable to find member'), code=404)
if not membership:
raise action_error(_('not a member of group'), code=400)
if role not in group_member_roles.enums:
raise action_error('not a valid role', code=400)
# AllanC - permisions moved to controller
#if not group.is_admin(c.logged_in_persona):
# raise action_error(_('no permissions for this group'), 403)
# AllanC - integrtiy moved to model
#if membership.role=="admin" and num_admins<=1:
# raise action_error('cannot remove last admin', 400)
from pylons import tmpl_context as c
membership.role = role
if membership.status == "request":
membership.status = "active"
member.send_notification(
messages.group_request_accepted(admin=c.logged_in_user,
group=group,
you=member))
group.send_notification(
messages.group_new_member(member=member, group=group))
else:
group.send_notification(
messages.group_role_changed(admin=c.logged_in_user,
member=member,
group=group,
role=role))
if not delay_commit:
Session.commit()
#invalidate_member(group)
#invalidate_member(member)
return True
def remove_member(group, member, delay_commit=False):
group = get_group(group)
member = get_member(member)
membership = get_membership(group, member)
if not group:
raise action_error(_('unable to find group'), code=404)
if not member:
raise action_error(_('unable to find member'), code=404)
if not membership:
raise action_error(_('not a member of group'), code=400)
# AllanC - permissions moved to controller
#if member!=c.logged_in_persona and not group.is_admin(c.logged_in_persona):
# raise action_error('current user has no permissions for this group', 403)
#AllanC - integrety moved to model
#if membership.role=="admin" and num_admins<=1:
# raise action_error('cannot remove last admin', 400)
# Notifications
if membership.status == "active": # member removed
from pylons import tmpl_context as c
if member != c.logged_in_user:
membership.member.send_notification(
messages.group_remove_member_to_member(admin=c.logged_in_user,
group=group))
group.send_notification(
messages.group_remove_member_to_group(admin=c.logged_in_user,
group=group,
member=member))
elif membership.status == "invite": # invitation declined
group.send_notification(
messages.group_invitation_declined(member=member, group=group))
elif membership.status == "request": # request declined
membership.member.send_notification(
messages.group_request_declined(group=group))
Session.delete(membership)
if not delay_commit:
Session.commit()
#invalidate_member(group)
#invalidate_member(member)
return True
def join_group(group, member, delay_commit=False):
return_value = True
group = get_group(group)
member = get_member(member)
membership = get_membership(group, member)
if not group:
raise action_error(_('unable to find group'), code=404)
if not member:
raise action_error(_('unable to find member to add'), code=404)
# AllanC - join permissions moved to controller
if membership and membership.status == "invite":
membership.status = "active"
else:
membership = GroupMembership()
membership.group = group
membership.member = member
membership.role = group.default_role
group.members_roles.append(membership)
# If a join request
if group.join_mode == "invite_and_request":
membership.status = "request"
return_value = "request"
group.send_notification(
messages.group_join_request(member=member, group=group))
# If user has actually become a member (open or reply to invite) then notify group
if return_value == True:
group.send_notification(
messages.group_new_member(member=member, group=group))
if not delay_commit:
Session.commit()
#invalidate_member(group)
#invalidate_member(member)
return return_value
def invite(group, member, role, delay_commit=False):
group = get_group(group)
member = get_member(member)
membership = get_membership(group, member)
role = role or group.default_role
if not group:
raise action_error(_('unable to find group'), code=404)
if not member:
raise action_error(_('unable to find member'), code=404)
if membership:
raise action_error(_('already a member of group'), code=400)
if role not in group_member_roles.enums:
raise action_error('not a valid role', code=400)
# AllanC - permissions moved to controller
#if not group.is_admin(c.logged_in_persona):
# raise action_error(_('no permissions for this group'), 403)
membership = GroupMembership()
membership.group = group
membership.member = member
membership.role = role
membership.status = "invite"
group.members_roles.append(membership)
# Notification of invitation
from pylons import tmpl_context as c
member.send_notification(
messages.group_invite(admin=c.logged_in_user,
group=group,
role=membership.role,
you=member))
if not delay_commit:
Session.commit()
#invalidate_member(group)
#invalidate_member(member)
return True
def test_delete_user(self):
self.assertEqual(self.num_members_public(username='******'), 0)
self.assertEqual(self.num_content_public('delete_cascade'), 0)
num_members_start = self.num_members_public()
num_content_start = self.num_content_public()
#-----------------------------------------------------------------------
# Step 1: Create a set of interlinked objects over a range of tables to test delete cascades
#-----------------------------------------------------------------------
# Create user
self.sign_up_as('delete_cascade')
response = self.app.get(url('member',
id='delete_cascade',
format='json'),
status=200)
response_json = json.loads(response.body)
self.delete_cascade_member_id = response_json['data']['member']['id']
self.assertNotEqual(self.delete_cascade_member_id, 0)
self.assertEqual(self.num_members_public(), num_members_start + 1)
# Setup known objects for delete cascade - Create a record in every related table to 'delete_cascade' member
# when searching through the database after the deletion has occoured there should be NO trace of the string 'delete_cascade' anywhere!
# - follow
# - messages
# - content
# - group membership
# Create content with media
self.png1x1 = self.generate_image((1, 1))
response = self.app.post(
url('contents', format='json'),
params={
'_authentication_token': self.auth_token,
'title': u'Testing delete_cascade',
'contents': u'delete_cascade delete_cascade',
'type': u'assignment',
'tags_string': u'delete_cascade',
#'submit_publish': u'publish' ,
},
upload_files=[("media_file", "1x1.png", self.png1x1)],
status=201)
response_json = json.loads(response.body)
self.content_id = int(response_json['data']['id'])
self.assertNotEqual(self.content_id, 0)
response = self.app.get(url('content',
id=self.content_id,
format='json'),
status=200)
response_json = json.loads(response.body)
self.media_id = response_json['data']['content']['attachments'][0][
'id']
self.assertNotEqual(self.media_id, 0)
# record current number of
response = self.app.get(url('member', id='unittest', format='json'),
status=200)
response_json = json.loads(response.body)
num_following = response_json['data']['following']['count']
num_followers = response_json['data']['followers']['count']
num_boomed_content = response_json['data']['boomed']['count']
#num_sent_messages =
# Following, message recive, boom, comment
self.log_in_as('unittest')
self.follow('delete_cascade')
self.send_member_message(
'delete_cascade', 'testing delete_cascade',
'this message should never be seen as it part of the delete_cascade test'
)
self.boom_content(self.content_id)
self.comment(self.content_id, 'delete_cascade comment')
unittest_assingment_id = self.create_content(type='assignment',
title='assignment',
content='assignment')
# Follow, message send, comment
self.log_in_as('delete_cascade')
self.follow('unittest')
self.send_member_message(
'unittest', 'testing delete_cascade',
'this message should never be seen as it part of the delete_cascade test'
)
self.comment(self.content_id, 'delete_cascade comment')
# TODO: accept assignment by unittest
self.accept_assignment(unittest_assingment_id)
self.withdraw_assignment(unittest_assingment_id)
response = self.app.get(url('member', id='unittest', format='json'),
status=200)
response_json = json.loads(response.body)
self.assertEqual(num_following + 1,
response_json['data']['following']['count'])
self.assertEqual(num_followers + 1,
response_json['data']['followers']['count'])
self.assertEqual(num_boomed_content + 1,
response_json['data']['boomed']['count'])
# Create group - and therefor become a member
self.group_id = self.create_group(
username='******',
name='Test group for delete_cascade',
description=
'This group should not be visible once the tests have completed because it will be removed',
default_role='contributor',
join_mode='public',
member_visibility='public',
default_content_visibility='public',
)
self.set_account_type(
'plus') # Create an account record associated with this user
self.delete_cascade_payment_account_id = Session.query(
Member).filter_by(id=self.delete_cascade_member_id).one(
).payment_account_id # Get payment account id
#-----------------------------------------------------------------------
# Step 2: check data is in database
#-----------------------------------------------------------------------
# check tables deeply for all instances of the member id for removal
self.assertEqual(
self.num_members_public(username='******'), 1
) # 'delete_cascade' and 'delete_cascade_group' are both public members
self.assertEqual(
self.num_members_public(username='******'), 1)
self.assertEqual(
self.num_content_public('delete_cascade'), 1
) # 'delete_cascade' in public content # unittest assignment has delete cascade in title and content
self.assertEqual(
Session.query(Media).filter_by(id=self.media_id).count(), 1)
self.assertEqual(
Session.query(Content).filter_by(id=self.content_id).count(), 1)
self.assertEqual(
Session.query(Content).filter_by(
parent_id=self.content_id).count(), 2)
self.assertEqual(
Session.query(Boom).filter_by(content_id=self.content_id).count(),
1)
self.assertEqual(
Session.query(Member).filter_by(
id=self.delete_cascade_member_id).count(), 1)
#self.assertEqual(Session.query(Boom ).filter_by( member_id = self.delete_cascade_member_id).count(), 1) # The boom didnt come from the member 'delete_cascade'
self.assertEqual(
Session.query(GroupMembership).filter_by(
member_id=self.delete_cascade_member_id).count(), 1)
self.assertEqual(
Session.query(Follow).filter_by(
member_id=self.delete_cascade_member_id).count(), 1)
self.assertEqual(
Session.query(Follow).filter_by(
follower_id=self.delete_cascade_member_id).count(), 1)
self.assertEqual(
Session.query(MemberAssignment).filter_by(
member_id=self.delete_cascade_member_id).count(), 1)
#self.assertEqual(Session.query(Message ).filter_by( target_id = self.delete_cascade_member_id).count() == 1) # cant, 1 as notifications are generated and it is more than 1
self.assertEqual(
Session.query(Message).filter_by(
source_id=self.delete_cascade_member_id).count(), 1)
self.assertEqual(
Session.query(Tag).filter_by(name=u'delete_cascade').count(), 1)
self.assertEqual(
Session.query(Member).filter_by(
payment_account_id=self.delete_cascade_payment_account_id).
count(), 1)
#-----------------------------------------------------------------------
# Step 3: Delete objects
#-----------------------------------------------------------------------
member_delete_cascade = get_member('delete_cascade')
member_delete_cascade.delete()
group_delete_cascade = get_group('delete_cascade_group')
self.assertEqual(group_delete_cascade.num_members, 0)
group_delete_cascade.delete()
#-----------------------------------------------------------------------
# Step 4: Check for successful removal
#-----------------------------------------------------------------------
self.assertEqual(self.num_members_public(username='******'), 0)
self.assertEqual(
self.num_members_public(username='******'), 0)
self.assertEqual(self.num_content_public('delete_cascade'), 0)
self.assertEqual(num_members_start, self.num_members_public())
self.assertEqual(num_content_start,
self.num_content_public() -
1) # -1 because unittest set an assignment
# check current number of
response = self.app.get(url('member', id='unittest', format='json'),
status=200)
response_json = json.loads(response.body)
self.assertEqual(num_following,
response_json['data']['following']['count'])
self.assertEqual(num_followers,
response_json['data']['followers']['count'])
self.assertEqual(num_boomed_content,
response_json['data']['boomed']['count'])
# check tables deeply for all instances of the member id for removal
self.assertEqual(
Session.query(Media).filter_by(id=self.media_id).count(), 0)
self.assertEqual(
Session.query(Content).filter_by(id=self.content_id).count(), 0)
self.assertEqual(
Session.query(Content).filter_by(
parent_id=self.content_id).count(), 0)
self.assertEqual(
Session.query(Boom).filter_by(content_id=self.content_id).count(),
0)
self.assertEqual(
Session.query(Member).filter_by(
id=self.delete_cascade_member_id).count(), 0)
self.assertEqual(
Session.query(Boom).filter_by(
member_id=self.delete_cascade_member_id).count(), 0)
self.assertEqual(
Session.query(GroupMembership).filter_by(
member_id=self.delete_cascade_member_id).count(), 0)
self.assertEqual(
Session.query(Follow).filter_by(
member_id=self.delete_cascade_member_id).count(), 0)
self.assertEqual(
Session.query(Follow).filter_by(
follower_id=self.delete_cascade_member_id).count(), 0)
self.assertEqual(
Session.query(MemberAssignment).filter_by(
member_id=self.delete_cascade_member_id).count(), 0)
self.assertEqual(
Session.query(Message).filter_by(
target_id=self.delete_cascade_member_id).count(), 0)
self.assertEqual(
Session.query(Message).filter_by(
source_id=self.delete_cascade_member_id).count(), 0)
self.assertEqual(
Session.query(Tag).filter_by(name=u'delete_cascade').count(), 1
) #Tag remains at the end, this could be tidyed witha delete orphan cascade
self.assertEqual(
Session.query(Member).filter_by(
payment_account_id=self.delete_cascade_payment_account_id).
count(), 0)
self.assertEqual(
Session.query(PaymentAccount).filter_by(
id=self.delete_cascade_payment_account_id).count(),
1) # The cascade dose not remove the payment account
# Step 5: cleanup
unittest_assignment = get_content(unittest_assingment_id)
unittest_assignment.delete()