def create_permissions(app, created_models, verbosity, **kwargs):
from django.contrib.contenttypes.models import ContentType
autodiscover()
reports = all_reports()
# This will hold the permissions we're looking for as
# (content_type, (codename, name))
searched_perms = list()
ctype = ContentType.objects.get_for_model(auth_app.User)
for slug, report in reports:
for perm in report.permissions:
searched_perms.append((ctype, perm))
# Find all the Permissions that have a context_type for a model we're
# looking for. We don't need to check for codenames since we already have
# a list of the ones we're going to create.
all_perms = set(
auth_app.Permission.objects.filter(content_type=ctype, ).values_list(
"content_type", "codename"))
objs = [
auth_app.Permission(codename=codename, name=name, content_type=ctype)
for ctype, (codename, name) in searched_perms
if (ctype.pk, codename) not in all_perms
]
auth_app.Permission.objects.bulk_create(objs)
if verbosity >= 2:
for obj in objs:
print "Adding permission '%s'" % obj
def create_permissions(app, created_models, verbosity, **kwargs):
from django.contrib.contenttypes.models import ContentType
app_models = get_models(app)
# This will hold the permissions we're looking for as
# (content_type, (codename, name))
searched_perms = list()
# The codenames and ctypes that should exist.
ctypes = set()
for klass in app_models:
ctype = ContentType.objects.get_for_model(klass)
ctypes.add(ctype)
for perm in _get_all_permissions(klass._meta):
searched_perms.append((ctype, perm))
# Find all the Permissions that have a context_type for a model we're
# looking for. We don't need to check for codenames since we already have
# a list of the ones we're going to create.
all_perms = set()
ctypes_pks = set(ct.pk for ct in ctypes)
for ctype, codename in auth_app.Permission.objects.all().values_list(
'content_type', 'codename')[:1000000]:
if ctype in ctypes_pks:
all_perms.add((ctype, codename))
objs = [
auth_app.Permission(codename=codename, name=name, content_type=ctype)
for ctype, (codename, name) in searched_perms
if (ctype.pk, codename) not in all_perms
]
auth_app.Permission.objects.bulk_create(objs)
if verbosity >= 2:
for obj in objs:
print "Adding permission '%s'" % obj
def test_group_permissions(self):
perm = pmod.Permission()
perm.codename = 'firstpermission'
perm.name = 'First Permission Test'
perm.content_type = pmod.Permission.objects.get(
codename='add_user').content_type
perm.save()
self.assertTrue(
pmod.Permission.objects.filter(
codename='firstpermission').exists(),
msg="Permission - 'firstpermission' - should have been created")
group = pmod.Group()
group.name = "First Group"
group.save()
self.assertTrue(pmod.Group.objects.filter(name='First Group').exists(),
msg="Group = 'First Group' - should have been created")
group.permissions.add(
pmod.Permission.objects.get(codename='firstpermission'))
group.save()
self.assertTrue(
pmod.Group.objects.get(name='First Group').permissions.filter(
codename="firstpermission").exists(),
msg=
"Group - 'First Group' - should have the permission 'firstpermission'"
)
def mutate(self, info, data):
permission = auth_models.Permission()
permission.name = data.name
permission.codename = data.codename
permission.content_type_id = 1
permission.save()
return permission
def create_permissions(app, created_models, verbosity, db=DEFAULT_DB_ALIAS, **kwargs):
try:
get_model('auth', 'Permission')
except UnavailableApp:
return
if not router.allow_migrate(db, auth_app.Permission):
return
from django.contrib.contenttypes.models import ContentType
app_models = get_models(app)
# This will hold the permissions we're looking for as
# (content_type, (codename, name))
searched_perms = list()
# The codenames and ctypes that should exist.
ctypes = set()
for klass in app_models:
# Force looking up the content types in the current database
# before creating foreign keys to them.
ctype = ContentType.objects.db_manager(db).get_for_model(klass)
ctypes.add(ctype)
for perm in _get_all_permissions(klass._meta, ctype):
searched_perms.append((ctype, perm))
# Find all the Permissions that have a content_type for a model we're
# looking for. We don't need to check for codenames since we already have
# a list of the ones we're going to create.
all_perms = set(auth_app.Permission.objects.using(db).filter(
content_type__in=ctypes,
).values_list(
"content_type", "codename"
))
perms = [
auth_app.Permission(codename=codename, name=name, content_type=ctype)
for ctype, (codename, name) in searched_perms
if (ctype.pk, codename) not in all_perms
]
# Validate the permissions before bulk_creation to avoid cryptic
# database error when the verbose_name is longer than 50 characters
permission_name_max_length = auth_app.Permission._meta.get_field('name').max_length
verbose_name_max_length = permission_name_max_length - 11 # len('Can change ') prefix
for perm in perms:
if len(perm.name) > permission_name_max_length:
raise exceptions.ValidationError(
"The verbose_name of %s is longer than %s characters" % (
perm.content_type,
verbose_name_max_length,
)
)
auth_app.Permission.objects.using(db).bulk_create(perms)
if verbosity >= 2:
for perm in perms:
print("Adding permission '%s'" % perm)
def test_permissions_users(self):
p = pmod.Permission()
p.codename = 'Djugo'
p.name = 'Dar jugo'
p.content_type = pmod.Permission.objects.get(codename='add_user').content_type
p.save()
homer = amod.User.objects.get(username='******')
homer.user_permissions.add(pmod.Permission.objects.get(codename='Djugo'))
homer = amod.User.objects.get(username='******')
self.assertEqual(homer.has_perm('account.Djugo'), True, msg="User permissions did not set correctly")
def test_group_permissions(self):
g = pmod.Group()
g.name = 'Testers'
g.save()
g2 = pmod.Group.objects.get(name=g.name)
self.assertEqual(g.name, g2.name, msg='Group names do not match')
p = pmod.Permission()
p.codename = 'test_stuff'
p.name = 'Test all the stuff'
p.content_type = pmod.Permission.objects.get(codename='add_user').content_type
p.save()
p2 = pmod.Permission.objects.get(codename=p.codename)
self.assertEqual(p.name, p2.name, msg='Permission codenames do not match')
def test_permissions_groups(self):
p1 = pmod.Permission()
p1.codename = 'chile'
p1.name = 'Ser bakan'
p1.content_type = pmod.Permission.objects.get(codename='add_user').content_type
p1.save()
g1 = pmod.Group()
g1.name = 'Chileno'
g1.save()
g1.permissions.add(pmod.Permission.objects.get(codename='chile'))
homer = amod.User.objects.get(username='******')
homer.groups.add(pmod.Group.objects.get(name='Chileno'))
homer = amod.User.objects.get(username='******')
self.assertEqual(homer.has_perm('account.chile'), True, msg='Group permissions not setting correctly')
def create_permissions(app,
created_models,
verbosity,
db=DEFAULT_DB_ALIAS,
**kwargs):
try:
get_model('auth', 'Permission')
except UnavailableApp:
return
if not router.allow_syncdb(db, auth_app.Permission):
return
from django.contrib.contenttypes.models import ContentType
app_models = get_models(app)
# This will hold the permissions we're looking for as
# (content_type, (codename, name))
searched_perms = list()
# The codenames and ctypes that should exist.
ctypes = set()
for klass in app_models:
# Force looking up the content types in the current database
# before creating foreign keys to them.
ctype = ContentType.objects.db_manager(db).get_for_model(klass)
ctypes.add(ctype)
for perm in _get_all_permissions(klass._meta, ctype):
searched_perms.append((ctype, perm))
# Find all the Permissions that have a content_type for a model we're
# looking for. We don't need to check for codenames since we already have
# a list of the ones we're going to create.
all_perms = set()
ctypes_pks = set(ct.pk for ct in ctypes)
for ctype, codename in auth_app.Permission.objects.all().values_list(
'content_type', 'codename')[:1000000]:
if ctype in ctypes_pks:
all_perms.add((ctype, codename))
perms = [
auth_app.Permission(codename=codename, name=name, content_type=ctype)
for ctype, (codename, name) in searched_perms
if (ctype.pk, codename) not in all_perms
]
auth_app.Permission.objects.using(db).bulk_create(perms)
if verbosity >= 2:
for perm in perms:
print("Adding permission '%s'" % perm)
def test_user_permissions(self):
#Create a new permission
test_permission = pmod.Permission(
name='testing persmission',
codename='test',
content_type=pmod.Permission.objects.get(
codename='add_user').content_type)
test_permission.save()
#Give user new permission
self.homer.user_permissions.add(test_permission)
#Check to see if user has permission
self.assertTrue(self.homer.has_perm('account.test'),
msg="Persmission test was not added to user")
def test_group_permission(self):
p = pmod.Permission()
p.codename = 'NewPermission'
p.name = 'New Permission'
p.content_type = pmod.Permission.objects.get(
codename='add_user').content_type
p.save()
g1 = pmod.Group()
g1.name = 'NewGroup'
g1.save()
g1 = pmod.Group.objects.get(name='NewGroup')
g1.permissions.add(
pmod.Permission.objects.get(codename='NewPermission'))
u1 = amod.User.objects.get(id=3)
g1 = pmod.Group.objects.get(name='NewGroup')
u1.groups.add(g1)
self.assertTrue(u1.has_perm('account.NewPermission'))
def create_view_permissions(app, created_models, verbosity, **kwargs):
"""
Create 'view' permissions for all models.
``django.contrib.auth`` only creates add, change and delete permissions.
Since we want to support read-only views, we need to add our own
permission.
Copied from ``django.contrib.auth.management.create_permissions``.
"""
# Is there any reason for doing this import here?
app_models = get_models(app)
# This will hold the permissions we're looking for as
# (content_type, (codename, name))
searched_perms = list()
# The codenames and ctypes that should exist.
ctypes = set()
for klass in app_models:
ctype = contenttypes_models.ContentType.objects.get_for_model(klass)
ctypes.add(ctype)
opts = utils.model_options(klass)
perm = ('view_%s' % opts.object_name.lower(),
u'Can view %s' % opts.verbose_name_raw)
searched_perms.append((ctype, perm))
# Find all the Permissions that have a content_type for a model we're
# looking for. We don't need to check for codenames since we already have
# a list of the ones we're going to create.
all_perms = set(
auth_models.Permission.objects.filter(
content_type__in=ctypes, ).values_list("content_type", "codename"))
perms = [
auth_models.Permission(codename=codename,
name=name,
content_type=ctype)
for ctype, (codename, name) in searched_perms
if (ctype.pk, codename) not in all_perms
]
auth_models.Permission.objects.bulk_create(perms)
if verbosity >= 2:
for perm in perms:
logger.info("Adding permission '%s'" % perm)
def test_user_permissions(self):
p = pmod.Permission()
p.codename = 'winmyheart'
p.name = 'Win Over my heart'
p.content_type = pmod.Permission.objects.get(
codename='add_user').content_type
p.save()
ispermissionsaved = False
for p in pmod.Permission.objects.all():
if p.codename == 'winmyheart':
ispermissionsaved = True
self.assertTrue(ispermissionsaved, msg="Permission was not created")
u = amod.User.objects.get(username='******')
u.user_permissions.add(
pmod.Permission.objects.get(codename='winmyheart'))
self.assertEqual(u.get_all_permissions(), {'account.winmyheart'},
msg="User did not get permission")
