Пример #1
0
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
Пример #2
0
    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()
Пример #3
0
 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()
Пример #4
0
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>")
Пример #5
0
    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)
Пример #6
0
    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'))
Пример #7
0
    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.")
Пример #8
0
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()
Пример #9
0
    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)
Пример #10
0
    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)
Пример #11
0
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
        })
Пример #12
0
    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()))
Пример #13
0
    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()
Пример #14
0
    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
Пример #15
0
    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
Пример #16
0
 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)
Пример #17
0
    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)
Пример #18
0
    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,
        }
Пример #19
0
    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()
Пример #20
0
    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
Пример #21
0
    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
Пример #22
0
 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()
Пример #23
0
 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()
Пример #24
0
    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)
Пример #25
0
    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)
Пример #27
0
    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()
Пример #28
0
    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))
Пример #29
0
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
        })
Пример #30
0
    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)