Python Group.save方法代码示例

# 需要导入模块: from django.contrib.auth.models import Group [as 别名]
# 或者: from django.contrib.auth.models.Group import save [as 别名]
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()

# 需要导入模块: from django.contrib.auth.models import Group [as 别名]
# 或者: from django.contrib.auth.models.Group import save [as 别名]
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})

# 需要导入模块: from django.contrib.auth.models import Group [as 别名]
# 或者: from django.contrib.auth.models.Group import save [as 别名]
    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

# 需要导入模块: from django.contrib.auth.models import Group [as 别名]
# 或者: from django.contrib.auth.models.Group import save [as 别名]
 def setUp(self):
     self.tearDown()
     
     User(id=1, username='anonymous').save()
     settings.ANONYMOUS_USER_ID=1
     
     user = User(id=2, username='tester0')
     user.set_password('secret')
     user.save()
     user1 = User(id=3, username='tester1')
     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()

# 需要导入模块: from django.contrib.auth.models import Group [as 别名]
# 或者: from django.contrib.auth.models.Group import save [as 别名]
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)

# 需要导入模块: from django.contrib.auth.models import Group [as 别名]
# 或者: from django.contrib.auth.models.Group import save [as 别名]
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()

# 需要导入模块: from django.contrib.auth.models import Group [as 别名]
# 或者: from django.contrib.auth.models.Group import save [as 别名]
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)

# 需要导入模块: from django.contrib.auth.models import Group [as 别名]
# 或者: from django.contrib.auth.models.Group import save [as 别名]
class MyTardisResourceTestCase(ResourceTestCase):
    '''
    abstract class without tests to combine common settings in one place
    '''
    def setUp(self):
        super(MyTardisResourceTestCase, self).setUp()
        self.username = 'mytardis'
        self.password = 'mytardis'
        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': '[email protected]'},
            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)

# 需要导入模块: from django.contrib.auth.models import Group [as 别名]
# 或者: from django.contrib.auth.models.Group import save [as 别名]
 def create_product_group(self, sender, created, **kwargs):
     if created:
         group = Group(name='[email protected]{}'.format(instance.id))
         group.save()
         self.first_owner.groups.add(group) #????????
         self.product_group = group
         self.save()

# 需要导入模块: from django.contrib.auth.models import Group [as 别名]
# 或者: from django.contrib.auth.models.Group import save [as 别名]
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))

# 需要导入模块: from django.contrib.auth.models import Group [as 别名]
# 或者: from django.contrib.auth.models.Group import save [as 别名]
    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')

# 需要导入模块: from django.contrib.auth.models import Group [as 别名]
# 或者: from django.contrib.auth.models.Group import save [as 别名]
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='[email protected]',password='pass',first_name='Joe',last_name='Bloggs')
        self.correct_details = {
            'username':'test',
        }
        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)

# 需要导入模块: from django.contrib.auth.models import Group [as 别名]
# 或者: from django.contrib.auth.models.Group import save [as 别名]
    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)

# 需要导入模块: from django.contrib.auth.models import Group [as 别名]
# 或者: from django.contrib.auth.models.Group import save [as 别名]
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
    )

# 需要导入模块: from django.contrib.auth.models import Group [as 别名]
# 或者: from django.contrib.auth.models.Group import save [as 别名]
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()