Python models.Group类代码示例

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()

    def setUpAuth(self):
        self.user_ctype = ContentType.objects.get_for_model(User)
        self.group_ctype = ContentType.objects.get_for_model(Group)

        User.objects.all().delete()
        self.abe = User(username="Abe", email="[email protected]")
        self.jack = User(username="Jack", email="[email protected]")
        self.james = User(username="James", email="[email protected]")
        self.john = User(username="John", email="[email protected]")
        self.elton = User(username="Elton", email="[email protected]", pk=10)

        self.abe.save()
        self.jack.save()
        self.james.save()
        self.john.save()

        Group.objects.all().delete()
        self.rockers = Group(name="rockers")
        self.bluesmen = Group(name="bluesmen")
        self.jazzmen = Group(name="jazzmen")
        self.emos = Group(name="emos", pk=10)

        self.rockers.save()
        self.bluesmen.save()
        self.jazzmen.save()
        self.emos.save()

 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

    def setUpAuthData(self):
        self.group = Group(name='testgroup')
        self.group.save()

        self.othergroup = Group(name='othergroup')
        self.othergroup.save()

        self.unorm = User(username='norm', email='[email protected]')
        self.unorm.set_password('password')
        self.normpass = 'password'
        self.unorm.save()
        self.unorm.groups.add(self.group)
        self.unorm.save()

        self.ustaff = User(username='staff', email='[email protected]', is_staff=True)
        self.ustaff.set_password('password')
        self.ustaff.save()
        self.ustaff.groups.add(self.othergroup)
        self.ustaff.save()

        self.unobody = User(username='nobody', email='[email protected]')
        self.unobody.set_password('password')
        self.unobody.save()

        self.norm = Client()
        self.norm.login(username='norm', password='password')
        self.staff = Client()
        self.staff.login(username='staff', password='password')
        self.nobody = Client()
        self.nobody.login(username='nobody', password='password')

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})

    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': 'bar',
            'password': 'baz',
            '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)

    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"])

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

def add_course(stg, fcg):
    """ Look up the student and faculty WIND affils for a course.
    If they don't exist, create them.
    Add the default social work school faculty to the affils."""

    default_faculty = User.objects.filter(
        username__in=settings.DEFAULT_SOCIALWORK_FACULTY_UNIS)
    already_existing_student_affils = Group.objects.filter(name__icontains=stg)
    already_existing_faculty_affils = Group.objects.filter(name__icontains=fcg)

    #####################
    # FACULTY AFFILS:
    if not already_existing_faculty_affils:
        new_faculty_affil = Group(name=fcg)
        new_faculty_affil.save()
    else:
        # Faculty affil already exists.
        new_faculty_affil = already_existing_faculty_affils[0]

    #####################
    # STUDENT AFFILS:
    if not already_existing_student_affils:
        new_student_affil = Group(name=stg)
        new_student_affil.save()
    else:
        # Student affil already exists.
        new_student_affil = already_existing_student_affils[0]

    #####################
    for instructor in default_faculty:
        new_student_affil.user_set.add(instructor)
        new_student_affil.save()
        new_faculty_affil.user_set.add(instructor)
        new_faculty_affil.save()
        instructor.save()

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)

 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()

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))

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)

    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)

    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)