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)