def forwards(self, orm):
        if not db.dry_run:
            # some object classes can only be seen by root, like all users for
            # instance. Add the new object class RegistrationRequest to the group
            # which all project admins are part of, so they don't get a 403 forbidden
            # when trying to see requests for their project

            try:
                projectadmins = Group.objects.get(name="projectadmins")
            except Group.DoesNotExist as e:
                projectadmins = Group(name="projectadmins")
                # TODO add permissions for all comicmodels and registrationRequest
                projectadmins.save()

            # my god spent 2 hours on this line. But this fixes any issues with
            # default permissions for registrationrequest not being found..
            db.send_pending_create_signals()

            # each user in comic is part of this group projectadmins. With the
            # permission in this group you can determine which types of objects
            # regular adins can see and edit in the admin interface.

            self.add_standard_perms("comicmodels", "registrationrequest", projectadmins)
            self.add_standard_perms("comicmodels", "comicsite", projectadmins)
            self.add_standard_perms("comicmodels", "page", projectadmins)
    def testGetScenariosUserDoesntHavePermission(self):
        # If the user doesn't have the required permission, an empty
        # queryset is returned.
        scenario = ScenarioF.create(status_cache=Scenario.STATUS_APPROVED)
        project = ProjectF.create()
        scenario.set_project(project)
        scenarioproject = ScenarioProject.objects.get(scenario=scenario, project=project)
        scenarioproject.approved = True
        scenarioproject.save()

        user, _ = User.objects.get_or_create(username="******")
        group = Group()
        group.save()
        user.groups.add(group)

        group.projectgrouppermission_set.add(
            ProjectGroupPermission(group=group, project=project, permission=UserPermission.PERMISSION_SCENARIO_VIEW)
        )

        pm = permission_manager.UserPermissionManager(user)

        self.assertFalse(pm.check_permission(UserPermission.PERMISSION_SCENARIO_VIEW))
        self.assertEquals(0, len(pm.get_scenarios()))

        user.userpermission_set.add(UserPermission(permission=UserPermission.PERMISSION_SCENARIO_VIEW, user=user))

        self.assertTrue(pm.check_permission(UserPermission.PERMISSION_SCENARIO_VIEW))
        self.assertEquals(1, len(pm.get_scenarios()))
Пример #3
0
def create_user_groups(sender, **kwargs):
    # Create Registers group
    defined_group = Group(name='Registers')
    defined_group.save()
    # Create Doctors group
    defined_group = Group(name='Doctors')
    defined_group.save()
Пример #4
0
    def handle(self, *args, **options):        
        # collect static files
        call_command('collectstatic', interactive=False)

        # setup the database
        call_command('syncdb', interactive=True)
        
        # setup database for the Testers group
        try:
            testers = Group.objects.get(name='Testers')
        except Group.DoesNotExist:
            testers = Group(name='Testers')
            testers.save()
    
        # setup the database for the Subjects group
        try:
            subjects = Group.objects.get(name='Subjects')
        except Group.DoesNotExist:
            subjects = Group(name='Subjects')
            subjects.save()
        
        self.stdout.write('Tally is successfully initialized')
        
        # run the development server
        call_command('runserver')
Пример #5
0
 def init(self):
     from modoboa.admin.models import User, 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(Permission)
     for pname in ["view_permissions"]:
         perm = Permission.objects.get(content_type=ct, codename=pname)
         grp.permissions.add(perm)
     
     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
Пример #6
0
    def setUp(self):

        self.accounts = [('user1', 'pwd1', 'useronefirstname', 'useronelastname'),
                         ('user2', 'pwd2', 'usertwofirstname', 'usertwolastname'),
                         ('user3', 'pwd3', 'userthreefirstname', 'userthreelastname')]

        for (uname, pwd, first, last) in self.accounts:
            user = User.objects.create_user(uname, '', pwd)
            user.first_name = first
            user.last_name = last
            user.save()
            profile = UserProfile(user=user,
                                         isDjangoAccount=True)
            profile.save()
        self.users = User.objects.all()

        self.client = Client()
        login = self.client.login(username=self.accounts[0][0],
                                  password=self.accounts[0][1])
        self.assertTrue(login)

        self.groups = ['group1', 'group2', 'group3', 'group4']
        for groupname in self.groups:
            group = Group(name=groupname)
            group.save()
Пример #7
0
def allGroup(request):
	newgroupname=request.POST.get('newGroup', '')
	note=request.POST.get('note', '')
	
	#me=userQuerySet.get(username=request.user.username)
	me=request.user
	
	if newgroupname:
		groupQuerySet=Group.objects.all()
		newGroup=Group(groupName=newgroupname, note=note)
		newGroup.memberList.add(me)
		newGroup.save()
		
		os.makedirs('media/'+newgroupname+'/')
		
		#me=userQuerySet.get(username=request.user.username)
		#newGroup.usergroup_set.add(me)
		me.group_set.add(newGroup)
		#newGroup.save()
		me.save()
	
	joinGroupName=request.POST.get('join', '')
	if joinGroupName:
		groupQuerySet=Group.objects.all()
		joinGroup=groupQuerySet.get(groupName=joinGroupName)
		#me=userQuerySet.get(uername=request.user.username)
		me.group_set.add(joinGroup)
		me.save()
	
	myGroup=me.group_set
	
	return render_to_reponse('group.html', {'username': request.user.username, 'allGroup': Group.objects.all(), 'myGroup': myGroup})
Пример #8
0
 def handle(self, *args, **options):
     try:
         importGroup = Group.objects.get(name__exact='Imported Users')
     except ObjectDoesNotExist, e:
         importGroup = Group()
         importGroup.name = 'Imported Users'
         importGroup.save()
Пример #9
0
    def setUp(self):
        g = Group(name='h')
        g.save()

        c = Cred(title='testcred', password='******', group=g)
        c.save()

        d = Cred(title='todelete', password='******', group=g)
        d.save()
        d.delete()

        u = User(username='******')
        u.save()
        u.groups.add(g)
        u.save()

        f = User(username='******')
        f.save()

        s = User(username='******', is_staff=True)
        s.save()
        s.groups.add(g)
        s.save()

        self.c = c
        self.d = d
        self.u = u
        self.f = f
        self.s = s
    def testGetScenariosPermissionScenarioView(self):
        user, _ = User.objects.get_or_create(username="******")
        group = Group()
        group.save()
        user.groups.add(group)

        user.userpermission_set.add(UserPermission(permission=UserPermission.PERMISSION_SCENARIO_VIEW, user=user))

        project = ProjectF.create()
        # User can only see approved scenarios
        scenario = ScenarioF.create(status_cache=Scenario.STATUS_APPROVED)
        scenario.set_project(project)
        scenarioproject = ScenarioProject.objects.get(scenario=scenario, project=project)
        scenarioproject.approved = True
        scenarioproject.save()
        # So can't see this one
        scenario2 = ScenarioF.create(status_cache=Scenario.STATUS_WAITING)
        scenario2.set_project(project)

        group.projectgrouppermission_set.add(
            ProjectGroupPermission(group=group, project=project, permission=UserPermission.PERMISSION_SCENARIO_VIEW)
        )

        pm = permission_manager.UserPermissionManager(user)
        self.assertTrue(pm.check_permission(UserPermission.PERMISSION_SCENARIO_VIEW))
        scenarios = pm.get_scenarios()
        self.assertEquals(len(scenarios), 1)
        self.assertEquals(scenarios[0].id, scenario.id)
Пример #11
0
 def create_product_group(self, sender, created, **kwargs):
     if created:
         group = Group(name='ppg@{}'.format(instance.id))
         group.save()
         self.first_owner.groups.add(group) #????????
         self.product_group = group
         self.save()
Пример #12
0
def create_group(request):
    if request.method == "POST":
        form_group_name = GroupNameHandlerForm(request.POST)
        form_group_description = GroupDescriptionHandlerForm(request.POST)
        if form_group_name.is_valid() and form_group_description.is_valid():
            # create group
            group_name = form_group_name.cleaned_data["group_name"]
            group_description = form_group_description.cleaned_data["group_description"]

            # group name must be unique!
            # use user name + created time as group name
            unique_group_name = "".join(("[real]", request.user.username, unicode(datetime.now())))
            group = Group(name=unique_group_name)
            group.save()
            # create related group info to handle group information
            group_info = GroupInfo(name=group_name, description=group_description, group=group, owner=request.user)
            group_info.save()
            # add user to group manager
            group_info.manager.add(request.user)
            # relate user to group
            request.user.groups.add(group)
            # redirect to group page
            return redirect("group_page", group_info_id=group_info.id)
    else:
        form_group_name = GroupNameHandlerForm()
        form_group_description = GroupDescriptionHandlerForm()
    render_data_dict = {"form_group_name": form_group_name, "form_group_description": form_group_description}
    return render(request, "group_info/create_group_page.html", render_data_dict)
Пример #13
0
def group_save(sender, instance, created, *args, **kwargs):
    '''
    Add Group to Django Groups
    '''
    from groups_manager.settings import GROUPS_MANAGER
    if GROUPS_MANAGER['AUTH_MODELS_SYNC'] and instance.django_auth_sync:
        # create a name compatible with django group name limit of 80 chars
        prefix = GROUPS_MANAGER['GROUP_NAME_PREFIX']
        suffix = GROUPS_MANAGER['GROUP_NAME_SUFFIX']
        if suffix == '_$$random':
            suffix = '_%s' % str(uuid4())[:8]
        parent_name = ''
        if instance.parent:
            parent_name = '%s-' % instance.parent.name
        name = '%s%s%s%s' % (prefix, parent_name, instance.name, suffix)
        if not instance.django_group:
            django_group = DjangoGroup(name=name)
            django_group.save()
            instance.django_group = django_group
            instance.save()
        elif (instance.django_group.name != name and
              GROUPS_MANAGER['GROUP_NAME_SUFFIX'] != '_$$random') \
                or (instance.django_group.name[:-len(suffix)] != name[:-len(suffix)] and
                    GROUPS_MANAGER['GROUP_NAME_SUFFIX'] == '_$$random'):
            instance.django_group.name = name
            instance.django_group.save()
Пример #14
0
def make_group(**kwargs):
    i = get_next_id()
    defaults = {'name': 'group{}'.format(i)}
    defaults.update(**kwargs)
    obj = Group(**defaults)
    obj.save()
    return obj
Пример #15
0
	def create_profile(self, user, person, project, record_type, already_activated=False):

		salt = hashlib.sha1(str(random.random())).hexdigest()[:5]
		username = user.username
		if isinstance(username, unicode):
			username = username.encode('utf-8')
		if already_activated:
			activation_key = "ALREADY_ACTIVATED"
		else:
			activation_key = hashlib.sha1(salt+username).hexdigest()

		create_user = self.create(user=user,activation_key=activation_key, person = person, project=project, record_type = record_type )
		if already_activated:
			user.is_active = True
			user.is_staff = True
			user.save()

		from django.contrib.auth.models import Group

		try:
			g = Group.objects.get(name=record_type.clas)
		except:
			g = Group(name=record_type.clas)
			g.save()
		g.user_set.add(user)
		return create_user
Пример #16
0
def user_add_group(user, group_name):
    group = get_object_or_none(Group, name=group_name)
    if not group:
        group = Group(name=group_name)
        group.save()
    group.user_set.add(user)
    return True
Пример #17
0
def post_save_project_handler(sender, **kwargs):
    """
    fn that gets called after a QProject is saved;
    if it's just been created, then the corresponding permissions and groups need to be setup
    :param sender:
    :param kwargs:
    :return:
    """
    created = kwargs.pop("created", True)
    project = kwargs.pop("instance", None)
    if created:
        assert project.groups.count() == 0
        for group_suffix, permission_prefixes in GROUP_PERMISSIONS.iteritems():
            group_name = "{0}_{1}".format(project.name, group_suffix)
            group = Group(
                name=group_name
            )
            group.save()
            for permission_prefix in permission_prefixes:
                permission_codename = "{0}_{1}".format(permission_prefix, project.name)
                permission_description = "{0} {1} instances".format(permission_prefix, project.name)
                content_type = ContentType.objects.get(app_label=APP_LABEL, model='qproject')
                (permission, created_permission) = Permission.objects.get_or_create(
                    codename=permission_codename,
                    name=permission_description,
                    content_type=content_type,
                )
                group.permissions.add(permission)
            group.save()
            project.groups.add(group)
Пример #18
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)
Пример #19
0
 def setUp(self):
     self.tearDown()
     
     User(id=1, username='******').save()
     settings.ANONYMOUS_USER_ID=1
     
     user = User(id=2, username='******')
     user.set_password('secret')
     user.save()
     user1 = User(id=3, username='******')
     user1.set_password('secret')
     user1.save()
     
     group = Group(name='testing_group')
     group.save()
     
     cluster = Cluster(hostname='test.osuosl.test', slug='OSL_TEST')
     cluster.save()
     
     dict_ = globals()
     dict_['user'] = user
     dict_['user1'] = user1
     dict_['group'] = group
     dict_['cluster'] = cluster
     dict_['c'] = Client()
Пример #20
0
    def add_event_editor(self):
        group_permissions = [
            {
                'name': 'Event editor',
                'permissions': ['add_event', 'change_event']
            },
            {
                'name': 'Event admin',
                'permissions': ['add_event', 'change_event', 'delete_event', 'delete_registration']
            },
            {
                'name': 'Registration editor',
                'permissions': ['add_registration', 'change_registration']
            },
        ]

        for group_permission in group_permissions:
            try:
                group = Group.objects.get(name=group_permission.get('name'))
            except Group.DoesNotExist:
                group = Group(name=group_permission.get('name'))
                group.save()

            for permission_name in group_permission.get('permissions'):
                try:
                    permission = Permission.objects.get(codename=permission_name)
                    group.permissions.add(permission)
                except Permission.DoesNotExist, e:
                    raise e
                except Group.DoesNotExist, e:
                    raise e
Пример #21
0
def add_view(request, **kw):
    context = kw
    site = request.session['site']
    context['site'] = site
    
    if request.method == 'POST':
        form = AddTeamForm(request.POST)
        if form.is_valid():
            members_group = Group(name = form.cleaned_data['title'] + ' Members')
            members_group.save()
            moderators_group = Group(name = form.cleaned_data['title'] + ' Moderators')
            moderators_group.save()
            team = Team(
                title = form.cleaned_data['title'],
                description = form.cleaned_data['description'],
                membership_policy = form.cleaned_data['membership_policy'],
                members_group = members_group,
                moderators_group = moderators_group,
                creator = request.user,
            )
            team.save()
            if hasattr(site.active_section, '_counts'):
                delattr(site.active_section, '_counts')
            if hasattr(site.active_section, '_count_items'):
                delattr(site.active_section, '_count_items')
            request.user.groups.add(moderators_group)
            return HttpResponseRedirect('/teams/detail/%s/' % team.id)
    else:
        form = AddTeamForm()

    context['form'] = form
    return render_to_response(
        'teams/add.html',
        context
    )
Пример #22
0
def write_contacts():
    global contacts
    global allgroups

    for group in allgroups :
        grp = None
        try:
            grp = Group.objects.get(name=group)
        except :
            pass
        if not grp :
            grp = Group()
            grp.name = group
            grp.save()

    for contact in contacts :
        user = None
        try:
            user = User.objects.get(username=contact['email'])
        except :
            pass
        if not user :
            user = User()
            user.username = contact['email']
            user.email = contact['email']
            user.is_active = False
            user.last_name = contact['family_name']
            user.first_name = contact['given_name']
            user.save()
            for grp in contact['groups']:
                g = Group.objects.get(name=grp)
                g.user_set.add(user)

            user.save()
Пример #23
0
Файл: base.py Проект: bsu/GWM2
    def setUp(self):
        models.client.GanetiRapiClient = RapiProxy
        vm, cluster = self.create_virtual_machine()

        context = {}
        self.create_standard_users(context)
        self.create_users([
              ('user',{'id':69}),
              ('user1',{'id':88}),
              ('vm_admin',{'id':77}),
              ('vm_modify',{'id':75}),
              ('cluster_migrate',{'id':78}),
              ('cluster_admin',{'id':99}),
        ], context)
        globals().update(context)

        vm_admin.grant('admin', vm)
        vm_modify.grant('modify', vm)
        cluster_migrate.grant('migrate', cluster)
        cluster_admin.grant('admin', cluster)

        group = Group(id=42, name='testing_group')
        group.save()

        # XXX ensure namespaces for this module and child classes are updated
        context['c'] = Client()
        context['group'] = group
        context['vm'] = vm
        context['cluster'] = cluster
        globals().update(context)
        self.context.update(context)
Пример #24
0
def create_group(gname):
    if Group.objects.filter(name=gname):
        print "    group exists for %s" % gname
        return
    g = Group(name=gname)
    g.save()
    print "    created group %s" % gname
Пример #25
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()
Пример #26
0
def newregister(request):
  get_authcode = lambda randcode: md5(settings.SECRET_KEY + randcode).hexdigest()
  get_randcode = lambda: md5(str(getrandbits(64))).hexdigest()
  error = ""
  if request.method == "POST":
    
    form = NewRegisterForm(request.POST)


    if form.is_valid():
      username = form.cleaned_data['saname']
      password = form.cleaned_data['password1']
      email = form.cleaned_data['email']
      authcode = get_authcode(form.cleaned_data['randcode'])
      error = None
      randcode = form.cleaned_data['randcode']
      
      if settings.REGISTER_SA_VERIFICATION:
          try:
            profile = SAProfile(username)  
          except URLError:
            error = "Couldn't find your profile. Check you haven't made a typo and that SA isn't down."
          
          if LIVE:
    
            try:
              if len(UserProfile.objects.filter(sa_id=profile.get_id())) > 0:
                error = "You appear to have already registered with this SA account"
            except IDNotFoundError:
              error = "Your SA ID could not be found. Please contact Jonnty"
            
            if not profile.has_authcode(authcode):
              error = "Verification code not found on your profile."
        
      if len(User.objects.filter(username__iexact=username)):  
        error = "This username has already been taken. Please contact Jonnty to get a different one."
         
        
      if error is None:
        user = User.objects.create_user(username=username, email=email, password=password)
        try: g = Group.objects.get(name="Listener")
        except Group.DoesNotExist:
          g = Group(name="Listener")
          g.save()
          [g.permissions.add(Permission.objects.get(codename=s)) for s in permissions]
          g.save()
        user.groups.add(g)
        user.save()
        up = UserProfile(user=user)
        if LIVE:
          up.sa_id = profile.get_id()
        up.save()
        return HttpResponseRedirect(reverse(django.contrib.auth.views.login))
    else:
      randcode = request.POST['randcode']
  else:
    randcode = get_randcode()
    form = NewRegisterForm(initial={'randcode': randcode})
  authcode = get_authcode(randcode)
  return render_to_response('register.html', {'form': form, 'authcode': authcode, 'error':error}, context_instance=RequestContext(request))
Пример #27
0
class RestfulAuthPasswordResetRequestTestCase(TestCase):

    def setUp(self):
        self.bronze = Group(name='Bronze')
        self.bronze.save()
        self.silver = Group(name='Silver')
        self.silver.save()
        self.user = User.objects.create_user('test',email='*****@*****.**',password='******',first_name='Joe',last_name='Bloggs')
        self.correct_details = {
            'username':'******',
        }
        self.client = APIClient()


    def tearDown(self):
        Group.objects.all().delete()
        User.objects.all().delete()
        self.client = None

    def test_valid_reset_request(self):
        """Check a password reset email is sent provided all data is entered correctly"""
        response = self.client.post('/password_reset/',self.correct_details,format='json')
        self.assertEqual(response.status_code,status.HTTP_201_CREATED)
        self.assertEqual(len(mail.outbox),1)

    def test_reset_request_username_missing(self):
        """Check reset fails if the username is not recognised. Should report this error."""
        self.correct_details.pop('username')
        response = self.client.post('/password_reset/',self.correct_details,format='json')
        data = json.loads(response.content)
        self.assertEqual(response.status_code,status.HTTP_401_UNAUTHORIZED)
        self.assertTrue('username' in data) # Check for error message
        self.assertEqual(len(mail.outbox),0)
Пример #28
0
    def handle(self, *args, **options):
        groups = settings.DEFAULT_GROUPS
        for groupname in groups:

            try:
                g = Group.objects.get(name=groupname)
            except Group.DoesNotExist:
                g = Group()
                g.name = groupname
                g.save()

            if g.name == "Default":
                g.user_set = User.objects.all()

            g.permissions = []
            for permission in groups[groupname]:
                try:
                    p = Permission.objects.get(codename=permission)
                    g.permissions.add(p)
                except Permission.DoesNotExist:
                    if permission[0] == "*":
                        permissions = Permission.objects.filter(content_type__model=permission.split("_")[1])
                        for p in permissions:
                            g.permissions.add(p)
            g.save()
Пример #29
0
    def test_group_logo_is_not_present_on_list_view(self):
        """
        Verify that no logo exists in list view when a group doesn't have one.
        """

        test_group = Group(name="tester")
        test_profile = GroupProfile(
            group=test_group,
            title="test",
            slug="test",
            description="test",
            access="public"
        )
        test_group.save()
        test_profile.save()

        response = self.client.get(
            reverse("api_dispatch_list",
                    kwargs={"api_name": "api", "resource_name": "groups"})
        )
        response_payload = json.loads(response.content)
        returned = response_payload["objects"]
        group = [g for g in returned if g["title"] == test_profile.title][0]
        self.assertEqual(200, response.status_code)
        self.assertIsNone(group["logo"])
Пример #30
0
class MyTardisResourceTestCase(ResourceTestCase):
    '''
    abstract class without tests to combine common settings in one place
    '''
    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.user_profile = UserProfile(user=self.user).save()
        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 get_credentials(self):
        return self.create_basic(username=self.username,
                                 password=self.password)

    def get_apikey_credentials(self):
        return self.create_apikey(username=self.username,
                                  api_key=self.user.api_key.key)
Пример #31
0
def make(request):
    user_id = request.POST.get('userid')
    action = request.POST.get('action')
    if user_id and action:
        user = User.objects.get(id=user_id)
        try:
            group = Group.objects.get(name="teacher")
        except ObjectDoesNotExist:
            group = Group(name="teacher")
            group.save()
        if action == 'set':
            group.user_set.add(user)
            # create Message
            title = "<" + request.user.first_name + u">設您為教師"
            url = "/teacher/classroom"
            message = Message(title=title,
                              url=url,
                              publication_date=timezone.now())
            message.save()

            # message for group member
            messagepoll = MessagePoll(message_id=message.id, reader_id=user_id)
            messagepoll.save()
        else:
            group.user_set.remove(user)
            # create Message
            title = "<" + request.user.first_name + u">取消您為教師"
            url = "/"
            message = Message(title=title,
                              url=url,
                              publication_date=timezone.now())
            message.save()

            # message for group member
            messagepoll = MessagePoll(message_id=message.id, reader_id=user_id)
            messagepoll.save()
        return JsonResponse({'status': 'ok'}, safe=False)
    else:
        return JsonResponse({'status': 'no'}, safe=False)
Пример #32
0
    def create_groups_users(self):
        if not Group.objects.exists():
            for group in GROUPS:
                group = Group(name=group)
                group.save()

        if not User.objects.exists():
            superuser = User.objects.create_superuser(
                username="******", email="*****@*****.**", password="******"
            )
            superuser.save()
            agent = User.objects.create_user(
                username="******", email="*****@*****.**", password="******"
            )
            agent.agency = Agency.objects.all().first()
            agent.save()

        agent = User.objects.all().filter(
            username="******"
        ).first()
        group = Group.objects.get(name=GROUPS[0])
        group.user_set.add(agent)
Пример #33
0
def RoleAgregar(request):
    currentUser = User.objects.get(id=request.user.id)
    if (currentUser.is_superuser):
        form = GrupoForm(request.POST)
        if form.is_valid():
            nombreGrupo = request.POST['groupName']
            if Group.objects.filter(name__iexact=nombreGrupo):
                messages.add_message(request, messages.WARNING, 'Rol ya existe!')
                rol = Group(name=nombreGrupo)
                return render(request, 'RolesEdit.html', {'rol': rol, 'action': '/rol/add/', 'titulo': 'Crear Rol'})
            else:
                rol = Group.objects.create(name=nombreGrupo)
                rol.save()
                messages.add_message(request, messages.SUCCESS,
                                     'Rol Agregado!')  # Debo cambiar que los mensajes aparezcan en listar

        return HttpResponseRedirect('/rol/todos')
    else:
        data = {
            'error': 'agregar roles'
        }
        return render(request, 'sinPermisos.html', data)
Пример #34
0
 def test_access_equality_op3(self):
     """
     Group attribute differs => access models won't be equal.
     """
     g1 = Group(name="G1")
     g1.save()
     g2 = Group(name="G2")
     g2.save()
     some_folder = Folder.objects.create(title="some_folder",
                                         user=self.uploader_user)
     a1 = Access(access_type=Access.ALLOW,
                 access_inherited=False,
                 node=some_folder,
                 group=g1)
     a2 = Access(access_type=Access.ALLOW,
                 access_inherited=False,
                 node=some_folder,
                 group=g2)
     a1.save()
     a2.save()
     # group attribute differ
     self.assertNotEqual(a1, a2)
Пример #35
0
    def post(self, request):
        result = {}
        hu = HttpUtils(self.request)
        input_dict = hu.getRequestParam()

        if input_dict is not None:
            try:
                if "id" in input_dict.keys():
                    id = request.data["id"]
                    g = Group.objects.get(id=id)
                    g.group_id = input_dict.get('group_id', g.group_id)
                    g.user_id = input_dict.get('user_id', g.user_id)
                    g.save()
                    result['status'] = 0
                    result['msg'] = "保存成功"
                else:
                    group_id = input_dict.get('group_id', '')
                    user_id = input_dict.get('user_id', '')

                    error = ''
                    if not group_id:
                        error = 'GroupId不能为空'
                    elif not user_id:
                        error = 'UserId不能为空'
                    if error:
                        return HttpResponseBadRequest(error)

                    g = Group(group_id=group_id,user_id=user_id)
                    g.save()
                    result['status'] = 0
                    result['msg'] = "保存成功"
                    result['id'] = g.id
                    # result['info'] = ModuleSerializer(g).data
            except Exception as e:
                logger.error(e)
                result['status'] = 1
                result['msg'] = "保存失败"
                return HttpResponseBadRequest(result['msg'])
        return HttpResponse(json.dumps(result),content_type='application/json')
Пример #36
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()
Пример #37
0
class AuthUserViewTest(TestCase):
    def setUp(self):
        group_name = "My Test Group"
        self.group = Group(name=group_name)
        self.group.save()

        self.user = User(
            username='******',
            email='*****@*****.**',
            is_active=True,
            is_staff=True,
            is_superuser=True,
        )
        self.user.set_password('test')
        self.user.save()

    def test_user_noLogin(self):
        """ The User don't have been login """
        response = self.client.get(reverse('auth_user_list'))
        #self.assertContains(response.context,url)
        self.assertEqual(response.status_code, 302)
        self.assertEqual(response.url,
                         "/accounts/login/?next=/lte/auth/user/list")

    def test_user_list(self):
        """ The user can load the users list,  when it's login """
        self.client.login(username='******', password='******')
        response = self.client.get(reverse('auth_user_list'))
        #print (response)
        self.assertEqual(response.status_code, 200)
        self.assertQuerysetEqual(response.context['object_list'],
                                 ['<User: test>'])

    def test_user_group_list(self):
        """ The user can lad group, when it's login """
        self.client.login(username='******', password='******')
        response = self.client.get(reverse('auth_user_groups_list'))
        #print (response)
        self.assertQuerysetEqual(response.context['object_list'], [])
    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)
Пример #39
0
class RestfulAuthPasswordResetRequestTestCase(TestCase):
    def setUp(self):
        self.bronze = Group(name='Bronze')
        self.bronze.save()
        self.silver = Group(name='Silver')
        self.silver.save()
        self.user = User.objects.create_user('test',
                                             email='*****@*****.**',
                                             password='******',
                                             first_name='Joe',
                                             last_name='Bloggs')
        self.correct_details = {
            'username': '******',
        }
        self.client = APIClient()

    def tearDown(self):
        Group.objects.all().delete()
        User.objects.all().delete()
        self.client = None

    def test_valid_reset_request(self):
        """Check a password reset email is sent provided all data is entered correctly"""
        response = self.client.post('/password_reset/',
                                    self.correct_details,
                                    format='json')
        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
        self.assertEqual(len(mail.outbox), 1)

    def test_reset_request_username_missing(self):
        """Check reset fails if the username is not recognised. Should report this error."""
        self.correct_details.pop('username')
        response = self.client.post('/password_reset/',
                                    self.correct_details,
                                    format='json')
        data = json.loads(response.content)
        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
        self.assertTrue('username' in data)  # Check for error message
        self.assertEqual(len(mail.outbox), 0)
Пример #40
0
    def form_valid(self, form):
        # event
        config['event_name'] = form.cleaned_data['event_name']
        config['event_description'] = form.cleaned_data['event_description']
        config['event_date'] = form.cleaned_data['event_date']
        config['event_location'] = form.cleaned_data['event_location']
        config['event_organizer'] = form.cleaned_data['event_organizer']

        # welcome widget
        config['welcome_title'] = form.cleaned_data['welcome_title']
        config['welcome_text'] = form.cleaned_data['welcome_text']

        # system
        if form.cleaned_data['system_enable_anonymous']:
            config['system_enable_anonymous'] = True
            # check for Anonymous group and (re)create it as needed
            try:
                anonymous = Group.objects.get(name='Anonymous')
            except Group.DoesNotExist:
                default_perms = [
                    'can_see_agenda', 'can_see_projector', 'can_see_motion',
                    'can_see_assignment', 'can_see_dashboard'
                ]
                anonymous = Group()
                anonymous.name = 'Anonymous'
                anonymous.save()
                anonymous.permissions = Permission.objects.filter(
                    codename__in=default_perms)
                anonymous.save()
                messages.success(self.request,
                    _('Anonymous access enabled. Please modify the "Anonymous" ' \
                    'group to fit your required permissions.'))
        else:
            config['system_enable_anonymous'] = False

        messages.success(self.request,
                         _('General settings successfully saved.'))
        return super(GeneralConfig, self).form_valid(form)
Пример #41
0
    def handle(self, *args, **options):

        # Create Admin
        try:
            user = User.objects.create_user('admin', '*****@*****.**', 'admin')
            user.is_superuser = True
            user.is_staff = True
            user.save()
        except IntegrityError:
            pass

        # Pillbox Group
        try:
            group = Group()

            group.name = 'Pillbox'
            group.save()
        except IntegrityError:
            # Group already exists, so just pass
            group = Group.objects.filter(name='Pillbox')[:1].get()

        # Grab need permission ids
        permissions = Permission.objects.all()

        for p in permissions:
            if p.content_type.model not in ['group', 'permission', 'user']:
                if 'add' not in p.name or (p.content_type.model == 'import' and 'add' in p.name):
                    group.permissions.add(p)

        # Create Pillbox User
        try:
            user = User.objects.create_user('pillbox', '*****@*****.**', 'pillbox')
            user.is_staff = True
            user.groups.add(group)
            user.save()
        except IntegrityError:
            # User already exists, so just passs
            pass
def set_perms(groups, output=True):
    pmap = {'a': 'add_', 'c': 'change_', 'd': 'delete_'}

    for g in groups:
        query = Group.objects.filter(name=g['name'])
        if query.count() == 0:
            group = Group(name=g['name'])
            group.save()
            if output:
                print("Added Group: %s" % g['name'])

        else:
            if output:
                print("Using Group: %s" % g['name'])

            group = query[0]

        for c in g['codes']:
            for key, prefix in list(pmap.items()):
                if key in c[1]:
                    codename = prefix + c[0]

                    q = group.permissions.filter(codename=codename)
                    if q.count() == 0:
                        pm = Permission.objects.get(codename=codename)
                        group.permissions.add(pm)
                        if output:
                            print("  Added Permission: %s" % codename)

                    else:
                        if output:
                            print("  Skipping Permission: %s" % codename)

        if output:
            print("")

    if output:
        print("Set Permissions Complete\n\n")
Пример #43
0
class AdminViewTestCase(TestCase):
    def setUp(self):
        group_name = "My Test Group"
        self.group = Group(name=group_name)
        self.group.save()

        self.user = User(
            username='******',
            email='*****@*****.**',
            is_active=True,
            is_staff=True,
            is_superuser=True,
        )
        self.user.set_password('test')
        self.user.save()
        self.client.login(username='******', password='******')

    def tearDown(self):
        self.client.logout()

    def test_user_can_access(self):
        """user in group should have access
        """
        self.user.groups.add(self.group)
        self.user.save()
        self.client.login(username='******', password='******')
        response = self.client.get(reverse('auth_user_list'))
        self.assertEqual(response.status_code, 200)

    def test_admin_not_broken(self):
        response = self.client.get('/admin/')
        self.assertContains(response, '/admin/password_change/')
        self.assertNotContains(response,
                               "You don't have permission to edit anything")

    def test_admin_auth_not_broken(self):
        response = self.client.get('/admin/auth/')
        self.assertEqual(response.status_code, 200, response)
Пример #44
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)
Пример #45
0
class GroupTestCase(TestCase):
    """ test user group permissions """
    def setUp(self):
        self.credentials = base64.b64encode(b'email:password').decode("ascii")
        self.client.defaults[
            'HTTP_AUTHORIZATION'] = 'Basic ' + self.credentials
        self.group = Group(name='test')
        self.group.save()
        self.group.permissions.add(
            Permission.objects.get(name='Can add Firma'))
        self.user = User.objects.create_user(email="*****@*****.**",
                                             password="******")
        self.user.is_staff = True

    def test_user_can_access(self):
        """ tests if user with new group can access """

        self.user.groups.add(self.group)
        self.user.save()

        self.client.force_login(self.user, backend=None)
        response = self.client.get('/company/company/add/')
        self.assertEqual(response.status_code, 200,
                         u'user in group should have access')

    def test_user_cannot_access(self):
        """ tests if user without group cannot access """

        self.user.save()

        self.client.force_login(self.user, backend=None)
        response = self.client.get('/company/company/add/')
        self.assertEqual(response.status_code, 403,
                         u'user not in group should have not access')

    def tearDown(self):
        Group.objects.all().delete()
        User.objects.all().delete()
Пример #46
0
def test_memorify_single_relation_hidden_None():
    setup_test_environment()
    old_name = "django_app"

    from django.db import connection
    old_name = connection.creation.create_test_db(verbosity=1,
                                                  autoclobber=True)

    user = User()
    user.username = "******"
    user.save()

    group = Group()
    group.name = "test group"
    group.save()

    user.groups.add(group)
    user.save()

    memorify_m2m(user, {'groups': [1]})

    connection.creation.destroy_test_db(old_name, 1)
    teardown_test_environment()
 def test_unconfigured_group(self):
     with self.settings(SHIBAUTH_GROUP_ATTRIBUTES=[]):
         # After login the user will be created
         self.client.get(reverse('shibauth_rit:shibauth_info'),
                         **settings.SAMPLE_HEADERS)
         query = User.objects.all()
         # Ensure the user was created
         self.assertEqual(query.count(), 1)
         user = User.objects.get(username='******')
         # The user should have no groups
         self.assertEqual(user.groups.all().count(), 0)
         # Create a group and add the user
         g = Group(name='Testgroup')
         g.save()
         # Now we should have exactly one group
         self.assertEqual(Group.objects.all().count(), 1)
         g.user_set.add(user)
         # Now the user should be in exactly one group
         self.assertEqual(user.groups.all().count(), 1)
         self.client.get(reverse('shibauth_rit:shibauth_info'),
                         **settings.SAMPLE_HEADERS)
         # After a request the user should still be in the group.
         self.assertEqual(user.groups.all().count(), 1)
    def test_content_delete_authenticated_group_permission_can_delete(self):
        g = Group()
        g.name = 'test'
        g.save()
        g.user_set.add(self.test_user)

        permission = DBLayerGroup()
        permission.can_view = False
        permission.can_edit = False
        permission.can_delete = True
        permission.can_update = False
        permission.layer = self.layer
        permission.group = g
        permission.save()

        self.login_test_user()
        url = reverse('content-detail',
                      kwargs={
                          'name': self.layer.name,
                          'pk': self.location.pk
                      })
        response = self.client.delete(url)
        self.assertEqual(response.status_code, 204)
Пример #49
0
    def setUp(self):

        self.accounts = [
            ('user1', 'pwd1', 'useronefirstname', 'useronelastname'),
            ('user2', 'pwd2', 'usertwofirstname', 'usertwolastname'),
            ('user3', 'pwd3', 'userthreefirstname', 'userthreelastname')]

        for (uname, pwd, first, last) in self.accounts:
            user = User.objects.create_user(uname, '', pwd)
            user.first_name = first
            user.last_name = last
            user.save()
        self.users = User.objects.all()

        self.client = Client()
        login = self.client.login(username=self.accounts[0][0],
                                  password=self.accounts[0][1])
        self.assertTrue(login)

        self.groups = ['group1', 'group2', 'group3', 'group4']
        for groupname in self.groups:
            group = Group(name=groupname)
            group.save()
Пример #50
0
 def create(email: str, password: str, firstname: str,
            phone: str) -> 'Customer':
     if User.objects.filter(email=email).exists():
         raise IntegrityError("Email ID Duplicated")
     customer = Customer()
     customer.email = email
     customer.user = User.objects.create_user(email, email, password)
     customer.user.first_name = firstname
     customer.phone = phone
     customer.user.save()
     try:
         g = Group.objects.get(name=Customer.GROUP_NAME)
     except Group.DoesNotExist:
         g = Group(name=Customer.GROUP_NAME)
         g.save()
     try:
         customer.save()
     except IntegrityError:
         customer.user.delete()
         raise IntegrityError("Email ID Duplicated")
     g.user_set.add(customer.user)
     g.save()
     return customer
Пример #51
0
    def test_group_member_in_group_allowed(self):
        from django.contrib.auth.models import Group
        group = Group(name="allowed_group")
        other_group = Group(name="other_group")
        group.save()
        other_group.save()

        policy = OpenIDClientPolicy(openid_client=self.oidc_client)
        policy.allow_groups.set([group, other_group])
        policy.save()

        user = get_user_model()(username="******",
                                email="*****@*****.**")
        user.save()
        user.groups.set([group])
        user.save()

        self.assertTrue(policy.is_user_allowed(user))

        other_group.delete()
        group.delete()
        user.delete()
        policy.delete()
Пример #52
0
def groupadd(request):
    if request.method == 'GET':

        # 读取所有的权限
        perms = Permission.objects.exclude(name__istartswith='Can')
        context = {'perms': perms}
        return render(request, 'auth/group/add.html', context)
    elif request.method == 'POST':
        # 创建组
        g = Group(name=request.POST['name'])
        g.save()

        # 获取选择的所有权限
        prms = request.POST.getlist('prms', None)

        # 判断是否需要给组添加权限
        if prms:
            # 给组分配权限
            g.permissions.set(prms)
            g.save()

        return HttpResponse(
            '<script>location.href="/myadmin/auth/group/list"</script>')
Пример #53
0
def GroupCreateView(request):
    context = {}
    context["users"] = User.objects.all()
    if request.method == "GET":
        return render_to_response(
            "system/group_edit.html",
            context,
            context_instance = RequestContext(request)
        )
    else:
        group = Group(
            name = request.POST.get("name")
        )
        group.save()
        users_id = request.POST.getlist("users")
        if users_id:
            for id in users_id:
                group.user_set.add(
                    User.objects.get(pk=int(id))
                )
        return HttpResponseRedirect(
            "/system/group/"
        )
Пример #54
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()
        for perm in perms:
            group_staff.permissions.add(perm)
        user.groups.add(group_staff)

        user.save()
        return user
Пример #55
0
def group_add(request):
    vinfo = viewinfo.prepare(request)

    error_message = None

    if len(request.POST) > 0 and 'name' in request.POST:
        try:
            group_get = Group.objects.get(name=request.POST['name'])
            error_message = 'Group already exists'
        except Group.DoesNotExist:
            group_create = Group(name=request.POST['name'])
            group_create.save()
            return redirect('config:groups-list')
    else:
        instance_id = 0

    context = viewinfo.context(vinfo)
    localcontext = {
        'error_message': error_message,
    }
    context.update(localcontext)

    return render(request, 'config/group_add.html', context)
Пример #56
0
    def setUp(self):
        # scenario - topic1 :
        # post1 - user1 - unread
        # post2 - user2 - unread
        self.user1 = ProfileFactory().user
        self.user2 = ProfileFactory().user
        self.outsider = ProfileFactory().user

        # Create the bot accound and add it to the bot group
        self.bot = ProfileFactory().user
        bot_group = Group(name=settings.ZDS_APP["member"]["bot_group"])
        bot_group.save()
        self.bot.groups.add(bot_group)

        self.topic1 = PrivateTopicFactory(author=self.user1)
        self.topic1.participants.add(self.user2)
        self.post1 = PrivatePostFactory(privatetopic=self.topic1,
                                        author=self.user1,
                                        position_in_topic=1)

        self.post2 = PrivatePostFactory(privatetopic=self.topic1,
                                        author=self.user2,
                                        position_in_topic=2)
Пример #57
0
    def test_creation_with_m2m_relation_through(self):
        """
        Ensure that a model object with a m2m relation can be created where that
        relation uses a through table
        """
        group = Group(name='foo')
        group.save()
        self.assertEqual(0, User.objects.count())

        response = self.client.post('/customusers/', {
            'username': '******',
            'groups': [group.id]
        })

        self.assertEqual(response.status_code, 201)
        self.assertEqual(1, CustomUser.objects.count())

        user = CustomUser.objects.all()[0]
        self.assertEqual('bar', user.username)
        self.assertEqual(1, user.groups.count())

        group = user.groups.all()[0]
        self.assertEqual('foo', group.name)
Пример #58
0
class LoggedInTestCase(TestCase):
    def setUp(self):
        Product.objects.create(code='Machine1',
                               name='machine_1 desc',
                               type='maszyny',
                               mark='M',
                               price_a=10,
                               price_b=5,
                               price_c=7,
                               price_d=15,
                               is_active=True,
                               availability=10)

        group_name = "Dystrybutorzy_B"
        self.group_b = Group(name=group_name)
        self.group_b.save()
        group_name = "Dystrybutorzy_C"
        self.group_c = Group(name=group_name)
        self.group_c.save()

        self.user = User.objects.create_user('adam', '*****@*****.**',
                                             'adampassword')
        self.client.login(username='******', password='******')
Пример #59
0
 def test_group_logo_is_present_on_list_view(self):
     """Verify that a group's logo is rendered on list view."""
     test_group = Group(name="tester")
     test_profile = GroupProfile(group=test_group,
                                 title="test",
                                 slug="test",
                                 description="test",
                                 access="public",
                                 logo=SimpleUploadedFile(
                                     "dummy-file.jpg", b"dummy contents"))
     test_group.save()
     test_profile.save()
     response = self.client.get(
         reverse("api_dispatch_list",
                 kwargs={
                     "api_name": "api",
                     "resource_name": "groups"
                 }))
     response_payload = json.loads(response.content)
     returned = response_payload["objects"]
     group = [g for g in returned if g["title"] == test_profile.title][0]
     self.assertEqual(200, response.status_code)
     self.assertEqual(group["logo"], test_profile.logo.url)
Пример #60
0
 def readd_group(group_name, perms=[], direct_add=False):
     """
     Add permission from perms to group_name group.
     If group doesn't exist, new one is created.
     If direct_add is True, then perms is assumed to be Permission's instance. Otherwise it should be a string.
     """
     g = None
     try:
         # delete group if exist
         Group.objects.get(name=group_name).delete()
     except Group.DoesNotExist:
         pass
     # create a new one
     g = Group(name=group_name)
     g.save()
     for perm in perms:
         if direct_add or isinstance(perm, Permission):
             p = perm
         else:
             p = Permission.objects.get(codename=perm)
         assert isinstance(p, Permission)
         g.permissions.add(p)
     g.save()