def create_test_groups(names=None):
"""Creates a Group for each value in a list of names.
If no list is given, Groups are created for each item in a default list."""
groups = []
if names is None:
names = [
"appraisal_archivists",
"accessioning_archivists",
"managing_archivists",
]
for name in names:
if not Group.objects.filter(name=name).exists():
group = Group(name=name)
group.save()
groups.append(group)
print("Test group {group} created".format(group=group.name))
else:
print("Test group {group} already exists".format(group=name))
group = Group.objects.get(name=name)
groups.append(group)
return groups
def __init__(self, data=None, files=None, instance=None, prefix='page_permissions'):
if instance is None:
instance = Group()
self.instance = instance
initial_data = []
for page, page_permissions in groupby(
instance.page_permissions.select_related('page').order_by('page'), lambda pp: pp.page
):
initial_data.append({
'page': page,
'permission_types': [pp.permission_type for pp in page_permissions]
})
super(BaseGroupPagePermissionFormSet, self).__init__(
data, files, initial=initial_data, prefix=prefix
)
for form in self.forms:
form.fields['DELETE'].widget = forms.HiddenInput()
def setUpTestData(cls):
Group.objects.bulk_create([
Group(id=constants.ENTREPRENEUR_GROUP_ID, name="Entreprenuer",),
Group(id=constants.MENTOR_GROUP_ID, name="Mentor",),
Group(id=constants.ADVISOR_GROUP_ID, name="Advisor",),
Group(id=constants.ORGANIZATION_MANAGER_GROUP_ID, name="Org Manager",),
Group(id=constants.ORGANIZATION_ADMIN_GROUP_ID, name="Org Admin",),
Group(id=constants.CLIENT_MANAGER_GROUP_ID, name="Client Manager",),
Group(id=constants.SYSTEM_ADMIN_GROUP_ID, name="System Admin",),
])
user = User.objects.create_user( # Create our user.
email=TEST_USER_EMAIL,
username=TEST_USER_USERNAME,
password=TEST_USER_PASSWORD,
first_name=TEST_USER_FIRSTNAME,
last_name=TEST_USER_LASTNAME,
)
user.is_active = True
user.save()
def groupadd(request):
if request.method == "GET":
per = Permission.objects.exclude(name__istartswith="Can")
return render(request, "myadmin/group/add.html", {"per": per})
elif request.method == "POST":
# 获取选择的所有权限
l = request.POST.getlist("prms", None)
# 创建组
g = Group(name=request.POST['username'])
g.save()
# 判断是否需要给组添加权限
if l:
# 给组分配权限
g.permissions.set(l)
g.save()
return HttpResponse("<script>alert('成功');location.href='" +
reverse("auth_grouplist") + "'</script>")
def setUp(self):
self.profile1 = ProfileFactory()
self.profile2 = ProfileFactory()
self.anonymous_account = UserFactory(
username=settings.ZDS_APP["member"]["anonymous_account"])
self.bot_group = Group()
self.bot_group.name = settings.ZDS_APP["member"]["bot_group"]
self.bot_group.save()
self.anonymous_account.groups.add(self.bot_group)
self.anonymous_account.save()
self.topic1 = PrivateTopicFactory(author=self.profile1.user)
self.topic1.participants.add(self.profile2.user)
self.post1 = PrivatePostFactory(privatetopic=self.topic1,
author=self.profile1.user,
position_in_topic=1)
self.post2 = PrivatePostFactory(privatetopic=self.topic1,
author=self.profile2.user,
position_in_topic=2)
self.client.force_login(self.profile1.user)
def test_add_group_add_permissions(self):
"""tests adding a group, adding a user to that group, then adding permissions to the group and checking to see if the permissions register with the user"""
self.u1 = amod.User.objects.get(email='*****@*****.**')
g1 = Group()
g1.name = 'Salespeople'
g1.id = 1
g1.save()
# p1 = Permission()
# p1.name = 'Change product price'
# p1.codename = 'change_product_price'
# p1.content_type = ContentType.objects.get(id=1)
#
# g1.permissions.add(p1)
self.u1.groups.add(g1)
self.assertGreater(self.u1.groups.filter(name='Salespeople').count(), 0)
g1.permissions.add(Permission.objects.get(id=19))
self.assertTrue(self.u1.has_perm('account.refund_order'))
def handle(self, *args, **options):
self.stdout.write("Check if \"Forum.forum_admin\" permission exists.")
content_type = ContentType.objects.get_for_model(Forum)
perm = Permission(codename='forum_admin',
name='Is Forum global administrator',
content_type=content_type)
try:
perm = Permission.objects.get(codename=perm.codename,
name=perm.name,
content_type=perm.content_type)
self.stdout.write("Already exists. No need to create it.")
except:
self.stdout.write("Create \"Forum.forum_admin\" permission.")
perm.save()
self.stdout.write("Check if \"Forum Admins\" group exists.")
group = Group(name="Forum Admins")
try:
Group.objects.get(name="Forum Admins")
self.stdout.write("Already exists. No need to create it.")
except:
self.stdout.write("Create \"Forum Admins\" group.")
group.save()
group.permissions.add(perm)
self.stdout.write("Check if Main Forum exists.")
try:
Forum.objects.get(id=0)
self.stdout.write("Already exists. No need to create it.")
except:
f_name = raw_input(
"Main Forum name (if empty it'll be 'Main Forum'):")
if f_name == "":
f_name = "Main Forum"
self.stdout.write("Create Main Forum.")
f = Forum(name=f_name, local_id=0)
f.save()
self.stdout.write("Done.")
def groups():
'''sets up the groups'''
groupnames = [{
'n': 'Principal',
'p': None
}, {
'n': 'Bursar',
'p': None
}, {
'n': 'Dean(Residence)',
'p': None
}, {
'n': 'Dean(Academic Affairs)',
'p': None
}, {
'n': 'Chaplain',
'p': None
}, {
'n': 'Public Information Officer',
'p': None
}, {
'n': 'Special Assignments',
'p': None
}, {
'n': 'Administration',
'p': None
}, {
'n': 'Staff Advisor',
'p': None
}, {
'n': 'Faculty',
'p': None
}, {
'n': 'Students',
'p': None
}]
for i in groupnames:
a = Group()
a.name = i['n']
a.save()
def post(self, request, *args, **kwargs):
context = super(UsuarioClienteCreateView, self).get_context_data(**kwargs)
if request.POST['password'] and request.POST['password2']:
if request.POST['password'] == request.POST['password2']:
password = request.POST['password']
cliente = Cliente.objects.get(cedula=request.session['cedula'])
correo = cliente.correo
nuevo_usuario = User.objects.create_user(
username=correo,
password=password,
email=correo
)
nuevo_usuario.save()
cliente.usuario = nuevo_usuario
cliente.save()
try:
grupo = Group.objects.get(name='cliente-inmobiliaria')
grupo.user_set.add(nuevo_usuario)
except:
grupo = Group()
grupo.name = 'cliente-inmobiliaria'
grupo.save()
grupo.user_set.add(nuevo_usuario)
del request.session['cedula']
request.session['nuevo-registro'] = "Usted se ha registrado exitosamente. Por favor inicie sesión para continuar"
else:
cliente = Cliente.objects.get(cedula=self.request.session.get('cedula'))
context['cliente'] = cliente
context['no_match'] = "Las contraseñas no coinciden"
return render(request, self.template_name, context)
else:
context['vacio'] = 'Los campos de contraseña deben tener valores válidos'
cliente = Cliente.objects.get(cedula=self.request.session.get('cedula'))
context['cliente'] = cliente
return render(request, self.template_name, context)
return redirect("/cuenta/login/", request=request)
def test_dataset(self):
exp = Experiment(title='test exp1',
institution_name='monash',
created_by=self.user)
exp.save()
exp2 = Experiment(title='test exp2',
institution_name='monash',
created_by=self.user)
exp2.save()
group = Group(name="Test Manager Group")
group.save()
group.user_set.add(self.user)
facility = Facility(name="Test Facility",
manager_group=group)
facility.save()
instrument = Instrument(name="Test Instrument",
facility=facility)
instrument.save()
dataset = Dataset(description='test dataset1')
dataset.instrument = instrument
dataset.save()
dataset.experiments.set([exp, exp2])
dataset.save()
dataset_id = dataset.id
del dataset
dataset = Dataset.objects.get(pk=dataset_id)
self.assertEqual(dataset.description, 'test dataset1')
self.assertEqual(dataset.experiments.count(), 2)
self.assertIn(exp, list(dataset.experiments.iterator()))
self.assertIn(exp2, list(dataset.experiments.iterator()))
self.assertEqual(instrument, dataset.instrument)
target_id = Dataset.objects.first().id
self.assertEqual(
dataset.get_absolute_url(), '/dataset/%d' % target_id,
dataset.get_absolute_url() + ' != /dataset/%d' % target_id)
def editarUsuario(request, idUsuario):
if request.method == 'POST':
username = request.POST["username"]
password = request.POST["password"]
email = request.POST["email"]
first_name = request.POST["first_name"]
last_name = request.POST["last_name"]
grupo_get = request.POST["grupo"]
user = User.objects.get(id=int(idUsuario))
user.username = username
user.email = email
user.first_name = first_name
user.last_name = last_name
if password == '':
print('no se actualiza la contrasena')
else:
user.set_password(password)
user.save()
user.groups.clear()
grupo = Group.objects.filter(name=str(grupo_get))
user = User.objects.get(pk=user.id)
if grupo.exists():
user.groups.add(grupo[0])
else:
grupo = Group(name=grupo_get)
grupo.save()
user.groups.add(grupo)
return HttpResponseRedirect(reverse('verUsuarios'))
else:
cursor = connection.cursor()
cursor.execute(
"SELECT u.id, u.first_name, u.last_name, u.email, u.username, coalesce(g.name, 'no tiene un grupo asignado') as grupo FROM auth_user u LEFT JOIN auth_user_groups ug ON ug.user_id = u.id LEFT JOIN auth_group g ON g.id = ug.group_id WHERE u.id = %s",
[idUsuario])
# usuario = auth_user.objects.filter(auth_group = auth_user_groups.id).select_related()
usuario = dictfetchall(cursor)
rol = request.user.groups.get().name
return render(request, "admin/usuarios/editar/index.html", {
'usuario': usuario,
'rol': rol
})
def test_match_user(self):
ruleset = RuleSet("")
self.assertFalse(ruleset.has_group_filter)
self.assertEqual(ruleset.user_filter_type, RuleSet.USER_FILTER_ALL)
# start with no user / anonymous
self.assertTrue(ruleset.match_user(None))
self.assertTrue(ruleset.match_user(AnonymousUser()))
# now exclude anonymous
ruleset.user_filter_type = RuleSet.USER_FILTER_AUTH
self.assertFalse(ruleset.match_user(None))
self.assertFalse(ruleset.match_user(AnonymousUser()))
# create a real user, but still no group filter
bob = User.objects.create_user("Bob")
self.assertFalse(bob.groups.exists())
self.assertFalse(bob.is_staff)
self.assertTrue(bob.is_authenticated())
self.assertTrue(ruleset.match_user(bob))
# now create the filter, and check bob no longer matches
ruleset.user_filter_type = RuleSet.USER_FILTER_GROUP
ruleset.user_group_filter = "test"
test_group = Group(name="test")
test_group.save()
self.assertFalse(ruleset.match_user(bob))
# add bob to the group, and check he now matches
bob.groups.add(test_group)
self.assertTrue(bob.groups.filter(name="test").exists())
self.assertTrue(ruleset.match_user(bob))
# test setting an invalid value
ruleset.user_filter_type = -1
self.assertFalse(ruleset.match_user(bob))
bob.is_staff = False
self.assertFalse(ruleset.match_user(bob))
self.assertFalse(ruleset.match_user(None))
self.assertFalse(ruleset.match_user(AnonymousUser()))
def setUp(self):
self.staff = StaffProfileFactory().user
settings.EMAIL_BACKEND = "django.core.mail.backends.locmem.EmailBackend"
self.mas = ProfileFactory().user
self.overridden_zds_app["member"]["bot_account"] = self.mas.username
self.licence = LicenceFactory()
self.subcategory = SubCategoryFactory()
self.user_author = ProfileFactory().user
self.user_staff = StaffProfileFactory().user
self.user_guest = ProfileFactory().user
self.tuto = PublishableContentFactory(type="TUTORIAL")
self.tuto.authors.add(self.user_author)
UserGalleryFactory(gallery=self.tuto.gallery,
user=self.user_author,
mode="W")
self.tuto.licence = self.licence
self.tuto.subcategory.add(self.subcategory)
self.tuto.save()
self.beta_forum = ForumFactory(
pk=self.overridden_zds_app["forum"]["beta_forum_id"],
category=ForumCategoryFactory(position=1),
position_in_category=1,
) # ensure that the forum, for the beta versions, is created
self.tuto_draft = self.tuto.load_version()
self.part1 = ContainerFactory(parent=self.tuto_draft,
db_object=self.tuto)
self.chapter1 = ContainerFactory(parent=self.part1,
db_object=self.tuto)
self.extract1 = ExtractFactory(container=self.chapter1,
db_object=self.tuto)
bot = Group(name=self.overridden_zds_app["member"]["bot_group"])
bot.save()
def _prepare(cls, create, **kwargs):
password = kwargs.pop('password', None)
user = super(StaffFactory, cls)._prepare(create, **kwargs)
if password:
user.set_password(password)
if create:
user.save()
group_staff = Group.objects.filter(name='staff').first()
if group_staff is None:
group_staff = Group(name='staff')
group_staff.save()
hat, _ = Hat.objects.get_or_create(name__iexact='Staff',
defaults={'name': 'Staff'})
hat.group = group_staff
hat.save()
perms = Permission.objects.filter(codename__startswith='change_').all()
group_staff.permissions = perms
user.groups.add(group_staff)
user.save()
return user
def setUp(self):
user = User.objects.create_user(username='******',
password='******')
group = Group(name='testing_group')
group.save()
# Creating Test Cluster
cluster = Cluster.objects.create(hostname='cluster0.example.test',
slug='cluster0')
# Creating Test nodes for the cluster.
node0 = Node.objects.create(cluster=cluster,
hostname='node0.example.test',
offline=False)
node1 = Node.objects.create(cluster=cluster,
hostname='node1.example.test',
offline=False)
# Creating Test instances for the cluster.
VirtualMachine.objects.create(cluster=cluster,
hostname='instance1.example.test',
primary_node=node0,
secondary_node=node1)
VirtualMachine.objects.create(cluster=cluster,
hostname='instance2.example.test',
primary_node=node0,
secondary_node=node1)
VirtualMachine.objects.create(cluster=cluster,
hostname='instance3.example.test',
primary_node=node0,
secondary_node=node1)
VirtualMachine.objects.create(cluster=cluster,
hostname='instance4.example.test',
primary_node=node1,
secondary_node=node0)
self.user = user
self.group = group
self.cluster = cluster
def post(self, request, *args, **kwargs):
try:
user = User.objects.get(email=request.POST['email'])
return JsonResponse(
{'message': 'User with this email already exists!'},
status=404)
except ObjectDoesNotExist:
try:
user = User.objects.create_user(
last_name=request.POST['last_name'],
first_name=request.POST['first_name'],
email=request.POST['email'],
username=request.POST['username'],
password=request.POST['password'])
user.save()
group = Group(name=request.POST['username'] + '_Personal')
group.save()
group.user_set.add(user)
return JsonResponse({'message': 'User successfully added!'},
status=201)
except IntegrityError:
return JsonResponse({'message': 'User exists'}, status=404)
def save(self, *args, **kwargs):
is_new = self.pk is None
if is_new: # group does not exist yet
new_name = self.display_name + '_' + sha256(bytes(datetime.utcnow().strftime("%d/%m/%Y %H:%M:%S"), 'UTF-8')).hexdigest() # TODO add randomness
new_base_group = Group(name=new_name) # TODO remove special chars from new_name
new_base_group.save()
self.group = new_base_group
# create forum for this group:
# new_forum = Forum()
new_forum = apps.get_model('forums.Forum')() # calling model manager to avoid circular import
new_forum.global_level = self.level_type
new_forum.forum_type = 'O' # hardcoded to avoid circular import
new_forum.name = "Forums for " + self.display_name
new_forum.save()
self.own_forums = new_forum
# if this group is a parent org, create shared forum:
if self.is_parent: # if we are the parent, create parental forums
# new_parent_forum = Forum()
new_parent_forum = apps.get_model('forums.Forum')() # calling model manager to avoid circular import
new_parent_forum.global_level = self.level_type
new_parent_forum.forum_type = 'S' # hardcoded to avoid circular import
new_parent_forum.name = "Forums for " + self.display_name + " and sub-organizations"
new_parent_forum.save()
self.parental_forums = new_parent_forum
else: # if we are not the parent, add parental forums to own model instance
if self.parent:
self.parental_forums = self.parent.parental_forums
super(OrganizationGroup, self).save(*args, **kwargs)
if is_new:
# create quota
new_quota = apps.get_model('quotas.Quota')() # calling model manager to avoid circular import
new_quota.pk = self.pk
new_quota.save()
new_forum.participant_organizations.add(self)
if self.is_parent or self.parent:
self.parental_forums.participant_organizations.add(self)
def setUp(self):
self.psf = baker.make("sponsors.SponsorshipProgram", name="PSF")
self.wk = baker.make("sponsors.SponsorshipProgram",
name="Working Group")
self.program_1_benefits = baker.make(SponsorshipBenefit,
program=self.psf,
_quantity=3)
self.program_2_benefits = baker.make(SponsorshipBenefit,
program=self.wk,
_quantity=5)
self.package = baker.make("sponsors.SponsorshipPackage",
advertise=True)
self.package.benefits.add(*self.program_1_benefits)
package_2 = baker.make("sponsors.SponsorshipPackage", advertise=True)
package_2.benefits.add(*self.program_2_benefits)
self.add_on_benefits = baker.make(SponsorshipBenefit,
program=self.psf,
_quantity=2)
self.a_la_carte_benefits = baker.make(
SponsorshipBenefit,
program=self.psf,
_quantity=2,
a_la_carte=True,
)
self.user = baker.make(settings.AUTH_USER_MODEL,
is_staff=True,
is_active=True)
self.client.force_login(self.user)
self.group = Group(name="Sponsorship Preview")
self.group.save()
self.data = {
"benefits_psf": [b.id for b in self.program_1_benefits],
"benefits_working_group": [b.id for b in self.program_2_benefits],
"add_ons_benefits": [b.id for b in self.add_on_benefits],
"a_la_carte_benefits": [b.id for b in self.a_la_carte_benefits],
"package": self.package.id,
}
def sync_accounts_from_stormpath(self, sync_groups=True):
""" :arg sync_groups: WARNING!!! Groups will be deleted from stormpath
if not present locally when user logs in!
Sync accounts from stormpath -> local database.
This may take a long time, depending on how many users you have in your
Stormpath application. It also makes numerous database queries.
This method updates local users from stormpath or creates new ones
where the user does not exist locally. This is an additive operation,
meaning it should delete no data from the local database OR stormpath.
"""
if sync_groups:
sp_groups = [g.name for g in APPLICATION.groups]
db_groups = set(Group.objects.all().values_list('name', flat=True))
missing_from_db = set(sp_groups).difference(db_groups)
if missing_from_db:
groups_to_create = []
for g_name in missing_from_db:
groups_to_create.append(Group(name=g_name))
Group.objects.bulk_create(groups_to_create)
for account in APPLICATION.accounts:
try:
user = StormpathUser.objects.get(email=account.email)
created = True
except StormpathUser.DoesNotExist:
user = StormpathUser()
created = True
user._mirror_data_from_stormpath_account(account)
user.set_unusable_password()
if created:
user._save_db_only()
if sync_groups:
users_sp_groups = [g.name for g in account.groups]
user.groups = Group.objects.filter(name__in=users_sp_groups)
user._save_db_only()
def init(self):
from modoboa.core.models import User
from modoboa.extensions.admin.models import Domain
ct = ContentType.objects.get(app_label="admin", model="domain")
dagrp = Group.objects.get(name="DomainAdmins")
grp = Group(name="Resellers")
grp.save()
grp.permissions.add(*dagrp.permissions.all())
ct = ContentType.objects.get_for_model(Domain)
for pname in ["view_domains", "add_domain", "change_domain", "delete_domain"]:
perm = Permission.objects.get(content_type=ct, codename=pname)
grp.permissions.add(perm)
grp.save()
for user in User.objects.filter(groups__name='DomainAdmins'):
try:
controls.create_pool(user)
except IntegrityError:
pass
def lookupSID(self, user_sid=None):
if user_sid == "S-1-1-0":
return ("AnonymousUser", "person")
try:
uc = UserCache.objects.get(user_sid=user_sid)
return (uc.user_obj, uc.user_class)
except UserCache.DoesNotExist:
try:
us = resolveUsernameOrGroup(user_sid)
if not us:
return
if us[1] == "user" or us[1] == "person":
try:
u = User.objects.get(username=us[0])
except:
u = User.objects.create_user(username=us[0])
if us[1] == "group":
try:
g = Group.objects.get(name=us[0])
except:
try:
g = Group(name=us[0])
g.save()
except:
pass
uc = UserCache(user_obj=us[0],
user_sid=user_sid,
user_class=us[1])
uc.save()
return (uc.user_obj, uc.user_class)
except Exception, exc:
try:
uc = UserCache.objects.get(user_sid=user_sid)
return (uc.user_obj, uc.user_class)
except Exception, exc:
logger.error("cannot create UserCache:%s" % (exc))
return None
def setUp(self):
super(MyTardisResourceTestCase, self).setUp()
self.username = '******'
self.password = '******'
self.user = User.objects.create_user(username=self.username,
password=self.password)
test_auth_service = AuthService()
test_auth_service._set_user_from_dict(
self.user,
user_dict={'first_name': 'Testing',
'last_name': 'MyTardis API',
'email': '*****@*****.**'},
auth_method="None")
self.testgroup = Group(name="Test Group")
self.testgroup.save()
self.testgroup.user_set.add(self.user)
self.testfacility = Facility(name="Test Facility",
manager_group=self.testgroup)
self.testfacility.save()
self.testinstrument = Instrument(name="Test Instrument",
facility=self.testfacility)
self.testinstrument.save()
def __init__(self):
self.list_perm_name = [
'add_coment',
'change_coment',
'view_coment',
'add_issue',
'change_issue',
'view_issue',
'add_issuestatus',
'change_issuestatus',
'view_issuestatus',
'add_project',
'change_project',
'view_project',
'add_sprint',
'can_add_coment_for_sprint',
'change_sprint',
'view_sprint',
'add_sprintstatus',
'change_sprintstatus',
'view_sprintstatus',
'add_statustask',
'change_statustask',
'view_statustask',
'add_task',
'can_add_coment_for_task',
'change_task',
'view_task',
'add_userstory',
'can_add_coment_for_userstory',
'change_userstory',
'view_userstory',
'add_userstorystatus',
'change_userstorystatus',
'view_userstorystatus',
'can_add_coment_for_issue',
'send_invitation',
]
self.perm_group = Group()
def test_creation_with_m2m_relation(self):
"""Ensure that a model object with a m2m relation can be created"""
group = Group(name='foo')
group.save()
self.assertEqual(0, User.objects.count())
response = self.client.post('/users/', {
'username': '******',
'password': '******',
'groups': [group.id]
})
self.assertEqual(response.status_code, 201)
self.assertEqual(1, User.objects.count())
user = User.objects.all()[0]
self.assertEqual('bar', user.username)
self.assertEqual('baz', user.password)
self.assertEqual(1, user.groups.count())
group = user.groups.all()[0]
self.assertEqual('foo', group.name)
def test_module_view(_reverse, resolve, setup_view, setup_helper, app,
middleware, kwargs):
"""Test that only registered users can access the setup view."""
resolve.return_value.namespaces = ['mockapp']
view = Mock()
setup_view.as_view.return_value = view
request = RequestFactory().get('/plinth/mockapp')
request.session = MagicMock()
setup_helper.is_finished = None
# Verify that anonymous users cannot access the setup page
request.user = AnonymousUser()
with pytest.raises(PermissionDenied):
middleware.process_view(request, **kwargs)
setup_view.as_view.assert_not_called()
view.assert_not_called()
# Verify that non-admin logged-in users can't access the setup page
user = User(username='******')
user.save()
request.user = user
with pytest.raises(PermissionDenied):
middleware.process_view(request, **kwargs)
setup_view.as_view.assert_not_called()
view.assert_not_called()
# Verify that admin logged-in users can access the setup page
user = User(username='******')
user.save()
group = Group(name='admin')
group.save()
user.groups.add(group)
user.save()
request.user = user
middleware.process_view(request, **kwargs)
setup_view.as_view.assert_called_once_with()
view.assert_called_once_with(request, app_id='mockapp')
def addDeveloper():
def addGroup(user, group):
user.groups.add(group)
user.save()
pass
developer = None
try:
developer = Group.objects.get(name='developers')
except Group.DoesNotExist:
developer = Group(name='developers')
developer.save()
for email in default_users:
try:
user = User.objects.get(email=email)
addGroup(user, developer)
except User.DoesNotExist:
print "-- ERROR: Can't find user" + str(email)
def run(self, params, args):
# Allow creation of one group only
if len(args) != 1:
raise ArgRequired(self, "group name")
groupname = args[0]
# Check to see if group name is alphanumeric
if not groupname.isalnum():
raise ArgError(self, "Group name", "must be alphanumeric")
# Check to see if group exists
try:
g = Group.objects.get(name=groupname)
except Group.DoesNotExist:
g = None
if g:
raise CommandError(self, "Group %s is already in use" % g)
# Create group
g = Group()
g.name = groupname
g.save()
def test_multiple_permissions_to_check(self):
groups = Group.objects.bulk_create(
[Group(name=name) for name in ['group1', 'group2', 'group3']])
access_rule = AccessRule.objects.create(
ctype_source=utils.get_content_type(User),
ctype_target=utils.get_content_type(Group),
relation_types=[{
'GROUPS': None
}])
add_perm = Permission.objects.get(content_type__app_label='auth',
codename='add_group')
change_perm = Permission.objects.get(content_type__app_label='auth',
codename='change_group')
access_rule.permissions.add(*[add_perm, change_perm])
self.user1.user_permissions.add(*[add_perm, change_perm])
self.user1.groups.add(*groups)
objects = utils.get_objects_for_user(
self.user1, ['auth.add_group', 'auth.change_group'])
self.assertEqual(len(groups), len(objects))
self.assertEqual(set(groups), set(objects))
def update_grupa(request, group_id=None):
if not request.user.groups.filter(name='Autorzy').exists():
messages.warning(request,
"Aby dodawać grupy, musisz należeć do grupy Autorzy")
return redirect('/grupy/')
object_list = Grupa.objects.filter(autor=request.user)
if (group_id):
group = Group.objects.select_related('grupa').get(pk=group_id)
else:
group = Group()
group.grupa = Grupa()
if request.method == 'POST':
group_form = GroupForm(request.POST, instance=group)
grupa_form = GrupaForm(request.POST, instance=group.grupa)
grupa_form.instance.autor = request.user
if group_form.is_valid() and grupa_form.is_valid():
group_form.instance.autor = request.user
group_form.instance.token = grupa_form.instance.token
group_form.save()
# grupa_form.instance.grupa = obj
# grupa_form.save()
messages.success(request, ('Dodano grupę'))
return redirect('pytania:grupa')
else:
messages.error(request, ('Popraw poniższe błędy.'))
else:
group_form = GroupForm(instance=group)
grupa_form = GrupaForm(instance=group.grupa)
return render(
request, 'pytania/grupa_form.html', {
'object_list': object_list,
'group_form': group_form,
'grupa_form': grupa_form
})
def test_creation_with_m2m_relation(self):
class UserResource(ModelResource):
model = User
def url(self, instance):
return "/users/%i" % instance.id
group = Group(name='foo')
group.save()
form_data = {'username': '******', 'password': '******', 'groups': [group.id]}
request = self.req.post('/groups', data=form_data)
cleaned_data = dict(form_data)
cleaned_data['groups'] = [group]
mixin = CreateModelMixin()
mixin.resource = UserResource
mixin.CONTENT = cleaned_data
response = mixin.post(request)
self.assertEquals(1, User.objects.count())
self.assertEquals(1, response.cleaned_content.groups.count())
self.assertEquals('foo', response.cleaned_content.groups.all()[0].name)
