def test_can_undo_share_community_with_group(self):
george = self.george
rebels = self.rebels
bikers = self.bikers
self.assertFalse(george.uaccess.can_undo_share_community_with_group(rebels, bikers))
self.assertEqual(
GroupCommunityPrivilege.get_privilege(community=rebels, group=bikers),
PrivilegeCodes.NONE)
george.uaccess.share_community_with_group(rebels, bikers, PrivilegeCodes.VIEW)
self.assertEqual(
GroupCommunityPrivilege.get_privilege(community=rebels, group=bikers),
PrivilegeCodes.VIEW)
self.assertTrue(george.uaccess.can_undo_share_community_with_group(rebels, bikers))
george.uaccess.undo_share_community_with_group(rebels, bikers)
self.assertEqual(
GroupCommunityPrivilege.get_privilege(community=rebels, group=bikers),
PrivilegeCodes.NONE)
self.assertFalse(george.uaccess.can_undo_share_community_with_group(rebels, bikers))
george.uaccess.share_community_with_group(rebels, bikers, PrivilegeCodes.VIEW)
self.assertEqual(
GroupCommunityPrivilege.get_privilege(community=rebels, group=bikers),
PrivilegeCodes.VIEW)
self.assertTrue(george.uaccess.can_undo_share_community_with_group(rebels, bikers))
george.uaccess.undo_share_community_with_group(rebels, bikers)
self.assertEqual(
GroupCommunityPrivilege.get_privilege(community=rebels, group=bikers),
PrivilegeCodes.NONE)
self.assertFalse(george.uaccess.can_undo_share_community_with_group(rebels, bikers))
def test_can_undo_share_community_with_group(self):
george = self.george
rebels = self.rebels
bikers = self.bikers
self.assertFalse(george.uaccess.can_undo_share_community_with_group(rebels, bikers))
self.assertEqual(
GroupCommunityPrivilege.get_privilege(community=rebels, group=bikers),
PrivilegeCodes.NONE)
george.uaccess.share_community_with_group(rebels, bikers, PrivilegeCodes.CHANGE)
self.assertEqual(
GroupCommunityPrivilege.get_privilege(community=rebels, group=bikers),
PrivilegeCodes.CHANGE)
self.assertTrue(george.uaccess.can_undo_share_community_with_group(rebels, bikers))
george.uaccess.undo_share_community_with_group(rebels, bikers)
self.assertEqual(
GroupCommunityPrivilege.get_privilege(community=rebels, group=bikers),
PrivilegeCodes.NONE)
self.assertFalse(george.uaccess.can_undo_share_community_with_group(rebels, bikers))
george.uaccess.share_community_with_group(rebels, bikers, PrivilegeCodes.VIEW)
self.assertEqual(
GroupCommunityPrivilege.get_privilege(community=rebels, group=bikers),
PrivilegeCodes.VIEW)
self.assertTrue(george.uaccess.can_undo_share_community_with_group(rebels, bikers))
george.uaccess.undo_share_community_with_group(rebels, bikers)
self.assertEqual(
GroupCommunityPrivilege.get_privilege(community=rebels, group=bikers),
PrivilegeCodes.NONE)
self.assertFalse(george.uaccess.can_undo_share_community_with_group(rebels, bikers))
def test_groupcommunityresult_update(self):
george = self.george
rebels = self.rebels
bikers = self.bikers
self.assertEqual(
GroupCommunityPrivilege.get_privilege(
community=rebels,
group=bikers),
PrivilegeCodes.NONE)
GroupCommunityPrivilege.update(
community=rebels,
group=bikers,
privilege=PrivilegeCodes.VIEW,
grantor=george)
self.assertEqual(
GroupCommunityPrivilege.get_privilege(
community=rebels,
group=bikers),
PrivilegeCodes.VIEW)
def test_groupcommunityresult_update(self):
george = self.george
rebels = self.rebels
bikers = self.bikers
self.assertEqual(
GroupCommunityPrivilege.get_privilege(
community=rebels,
group=bikers),
PrivilegeCodes.NONE)
GroupCommunityPrivilege.update(
community=rebels,
group=bikers,
privilege=PrivilegeCodes.CHANGE,
grantor=george)
self.assertEqual(
GroupCommunityPrivilege.get_privilege(
community=rebels,
group=bikers),
PrivilegeCodes.CHANGE)
def handle(self, *args, **options):
national_user = User.objects.get(username='******')
czo_community = Community.objects.get(name='CZO National Community')
czo_mapper = {}
for czo in czo_setup: # index by prefix
czo_mapper[czo[2]] = czo
# check each group in turn
for czo in czo_setup:
czo_username = czo[0]
czo_groupname = czo[1]
czo_prefix = czo[2] # prefix for all titles for this group.
print("CHECKING user {} against group {}".format(
czo_username, czo_groupname))
czo_user = User.objects.get(username=czo_username)
czo_group = Group.objects.get(name=czo_groupname)
user_resources = set(
BaseResource.objects.filter(r2urp__user=czo_user))
print(" There are {} user resources".format(len(user_resources)))
# for r in user_resources:
# print(" {} {}".format(r.short_id, r.title.encode('ascii', 'ignore')))
group_resources = set(
BaseResource.objects.filter(r2grp__group=czo_group))
print(" There are {} group resources".format(
len(group_resources)))
# for r in group_resources:
# print(" {} {}".format(r.short_id, r.title.encode('ascii', 'ignore')))
# check that group is in the community
if not Community.objects.filter(c2gcp__community=czo_community,
c2gcp__group=czo_group).exists():
print(" SHARING group {} with community {}".format(
czo_group.name, czo_community.name))
# fix it NOW
GroupCommunityPrivilege.share(group=czo_group,
community=czo_community,
privilege=PrivilegeCodes.VIEW,
grantor=national_user)
# check whether all resources are owned by czo national
for r in user_resources | group_resources:
if not UserResourcePrivilege.objects.filter(
user=national_user,
privilege=PrivilegeCodes.OWNER,
resource=r).exists():
print(" SHARING {} {} with czo national user".format(
r.short_id, r.title.encode('ascii', 'ignore')))
UserResourcePrivilege.share(user=national_user,
resource=r,
privilege=PrivilegeCodes.OWNER,
grantor=national_user)
# set quota holder to CZO national
set_quota_holder(r, national_user)
# Now everything is owned by CZO national so we can remove other owners safely.
if czo_user != national_user:
# Check that all resources have the appropriate prefix
for r in user_resources | group_resources: # or r in user_resources for non-czo
check_resource_prefix(czo_user, czo_group, r, czo_prefix,
czo_mapper, national_user)
# refresh for user and group changes from above
user_resources = set(
BaseResource.objects.filter(r2urp__user=czo_user))
group_resources = set(
BaseResource.objects.filter(r2grp__group=czo_group))
# Now every resource is filed in the appropriate group,
# and non-matching resources are owned by CZO National.
# group owner should own all group resources and vice versa.
# This will only pick up changes for resources that had the proper prefix.
if len(user_resources - group_resources) != 0:
print(
" The following user resources are not group resources"
)
for r in (user_resources - group_resources):
check_resource_group(czo_group, r, national_user)
# refresh group membership
group_resources = set(
BaseResource.objects.filter(r2grp__group=czo_group))
if len(group_resources - user_resources) != 0:
print(
" The following group resources are not user resources:"
)
for r in (group_resources - user_resources):
check_resource_owners(national_user, czo_user, r,
national_user)
# refresh ownership
user_resources = set(
BaseResource.objects.filter(r2urp__user=czo_user))
else:
# czo national user and group only runs this clause
# no assumption that user resources and group resources are the same.
# * user resources are all resources.
# * group resources are those that come from multiple sources.
# Check that all resources have the appropriate prefix
for r in group_resources: # no user_resources because that's everything
check_resource_prefix(czo_user, czo_group, r, czo_prefix,
czo_mapper, national_user)
# pick up changes from above
group_resources = set(
BaseResource.objects.filter(r2grp__group=czo_group))
for r in group_resources:
check_resource_group(czo_group, r, national_user)
# pick up changes from above
group_resources = set(
BaseResource.objects.filter(r2grp__group=czo_group))
for r in group_resources:
check_resource_owners(national_user, czo_user, r,
national_user)