├── .gitignore ├── CHANGELOG.rst ├── LICENSE ├── README.rst ├── permission_backend_nonrel ├── __init__.py ├── admin.py ├── backends.py ├── models.py ├── tests.py └── utils.py └── setup.py /.gitignore: -------------------------------------------------------------------------------- 1 | # use glob syntax. 2 | syntax: glob 3 | *.pyc 4 | *~ 5 | .ropeproject 6 | \#*\# 7 | .\#* 8 | *.orig 9 | 10 | .DS_Store 11 | -------------------------------------------------------------------------------- /CHANGELOG.rst: -------------------------------------------------------------------------------- 1 | Changelog 2 | ========= 3 | 4 | Version 0.2 (Dec 31, 2013) 5 | ------------- 6 | 7 | * Fixed query errors with Django 1.5 and 1.6 8 | 9 | Version 0.1 10 | ------------- 11 | 12 | * Initial release 13 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Copyright 2010 Florian Hahn. All rights reserved. 2 | 3 | Redistribution and use in source and binary forms, with or without modification, are 4 | permitted provided that the following conditions are met: 5 | 6 | 1. Redistributions of source code must retain the above copyright notice, this list of 7 | conditions and the following disclaimer. 8 | 9 | 2. Redistributions in binary form must reproduce the above copyright notice, this list 10 | of conditions and the following disclaimer in the documentation and/or other materials 11 | provided with the distribution. 12 | 13 | THIS SOFTWARE IS PROVIDED BY ``AS IS'' AND ANY EXPRESS OR IMPLIED 14 | WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND 15 | FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL OR 16 | CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 17 | CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 18 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 19 | ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 20 | NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 21 | ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 22 | 23 | The views and conclusions contained in the software and documentation are those of the 24 | authors and should not be interpreted as representing official policies, either expressed 25 | or implied, of . 26 | -------------------------------------------------------------------------------- /README.rst: -------------------------------------------------------------------------------- 1 | Django-permission-backend-nonrel 2 | ==================================== 3 | 4 | A Django authentication backend that supports Django's user and group permissions on Django-Nonrel_. 5 | 6 | 7 | Installation 8 | ==================================== 9 | 10 | * Get the code from Github: 11 | 12 | git clone https://github.com/django-nonrel/django-permission-backend-nonrel.git 13 | 14 | * add **permission_backend_nonrel.backends.NonrelPermissionBackend** to your *AUTHENTICATION_BACKENDS* 15 | and **permission_backend_nonrel** to your *INSTALLED_APPS* 16 | 17 | settings.py:: 18 | 19 | AUTHENTICATION_BACKENDS = ( 20 | ... 21 | 'permission_backend_nonrel.backends.NonrelPermissionBackend', 22 | ) 23 | 24 | INSTALLED_APPS = ( 25 | ... 26 | 'permission_backend_nonrel', 27 | ) 28 | 29 | * It's important to put **'permission_backend_nonrel** after **djangotoolbox**, 30 | because **permission_backend_nonrel.admin** replaces **djangotoolbox**'s User admin site. 31 | 32 | Permission and groups can be assigned and modified via Django's admin interface: 33 | 34 | .. figure:: http://floooofiles.appspot.com/serve/files/admin.jpeg/ 35 | :scale: 50 % 36 | :alt: Django-nonrel admin with user_permissions and groups 37 | 38 | Django-gaeauth admin interface with user_permissions and groups 39 | 40 | * Now you should be able to use all the standard Django permission methods and decorators, 41 | like *user.has_perm('foo')* and so on. 42 | 43 | 44 | .. _Django-Nonrel: http://django-nonrel.org/ 45 | -------------------------------------------------------------------------------- /permission_backend_nonrel/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/django-nonrel/django-permission-backend-nonrel/bd50dc3a74d7079163ec6b99ed5bf72e25a1d8d8/permission_backend_nonrel/__init__.py -------------------------------------------------------------------------------- /permission_backend_nonrel/admin.py: -------------------------------------------------------------------------------- 1 | from django import forms 2 | from django.contrib import admin 3 | from django.utils.translation import ugettext 4 | from django.contrib.auth.admin import UserAdmin 5 | from django.contrib.admin.sites import NotRegistered 6 | from django.contrib.auth.models import Group, Permission 7 | from django.contrib.admin.widgets import FilteredSelectMultiple 8 | 9 | from django.contrib.auth import get_user_model 10 | User = get_user_model() 11 | 12 | from .models import UserPermissionList, GroupPermissionList 13 | from .utils import update_permissions_user, \ 14 | update_user_groups, update_permissions_group 15 | 16 | 17 | class UserForm(forms.ModelForm): 18 | class Meta: 19 | model = User 20 | exclude = ('user_permissions', 'groups') 21 | 22 | class NonrelPermissionUserForm(UserForm): 23 | user_permissions = forms.MultipleChoiceField(required=False) 24 | groups = forms.MultipleChoiceField(required=False) 25 | 26 | def __init__(self, *args, **kwargs): 27 | super(NonrelPermissionUserForm, self).__init__(*args, **kwargs) 28 | 29 | self.fields['user_permissions'] = forms.MultipleChoiceField(required=False) 30 | self.fields['groups'] = forms.MultipleChoiceField(required=False) 31 | 32 | permissions_objs = Permission.objects.all().order_by('name') 33 | choices = [] 34 | for perm_obj in permissions_objs: 35 | choices.append([perm_obj.id, perm_obj.name]) 36 | self.fields['user_permissions'].choices = choices 37 | 38 | group_objs = Group.objects.all() 39 | choices = [] 40 | for group_obj in group_objs: 41 | choices.append([group_obj.id, group_obj.name]) 42 | self.fields['groups'].choices = choices 43 | 44 | try: 45 | user_perm_list = UserPermissionList.objects.get( 46 | user=kwargs['instance']) 47 | self.fields['user_permissions'].initial = user_perm_list.permission_fk_list 48 | self.fields['groups'].initial = user_perm_list.group_fk_list 49 | except (UserPermissionList.DoesNotExist, KeyError): 50 | self.fields['user_permissions'].initial = list() 51 | self.fields['groups'].initial = list() 52 | 53 | 54 | class NonrelPermissionCustomUserAdmin(UserAdmin): 55 | form = NonrelPermissionUserForm 56 | list_filter = ('is_staff', 'is_superuser', 'is_active') 57 | 58 | def save_model(self, request, obj, form, change): 59 | super(NonrelPermissionCustomUserAdmin, self).save_model(request, obj, form, change) 60 | try: 61 | if len(form.cleaned_data['user_permissions']) > 0: 62 | permissions = list(Permission.objects.filter( 63 | id__in=form.cleaned_data['user_permissions']).order_by('name')) 64 | else: 65 | permissions = [] 66 | 67 | update_permissions_user(permissions, obj) 68 | except KeyError: 69 | pass 70 | 71 | try: 72 | if len(form.cleaned_data['groups']) > 0: 73 | groups = list(Group.objects.filter( 74 | id__in=form.cleaned_data['groups'])) 75 | else: 76 | groups = [] 77 | 78 | update_user_groups(obj, groups) 79 | except KeyError: 80 | pass 81 | 82 | 83 | class PermissionAdmin(admin.ModelAdmin): 84 | ordering = ('name',) 85 | 86 | 87 | class GroupForm(forms.ModelForm): 88 | permissions = forms.MultipleChoiceField(required=False) 89 | 90 | def __init__(self, *args, **kwargs): 91 | # Temporarily exclude 'permissions' as it causes an 92 | # unsupported query to be executed 93 | original_exclude = self._meta.exclude 94 | self._meta.exclude = ['permissions',] + (self._meta.exclude if self._meta.exclude else []) 95 | 96 | super(GroupForm, self).__init__(*args, **kwargs) 97 | 98 | self._meta.exclude = original_exclude 99 | 100 | self.fields['permissions'] = forms.MultipleChoiceField(required=False, widget=FilteredSelectMultiple(ugettext('Permissions'), False)) 101 | 102 | permissions_objs = Permission.objects.all().order_by('name') 103 | choices = [] 104 | for perm_obj in permissions_objs: 105 | choices.append([perm_obj.id, perm_obj.name]) 106 | self.fields['permissions'].choices = choices 107 | 108 | try: 109 | current_perm_list = GroupPermissionList.objects.get( 110 | group=kwargs['instance']) 111 | self.fields['permissions'].initial = current_perm_list.permission_fk_list 112 | except (GroupPermissionList.DoesNotExist, KeyError): 113 | self.fields['permissions'].initial = [] 114 | 115 | class Meta: 116 | model = Group 117 | fields = ('name',) 118 | 119 | 120 | class CustomGroupAdmin(admin.ModelAdmin): 121 | form = GroupForm 122 | fieldsets = None 123 | 124 | def save_model(self, request, obj, form, change): 125 | super(CustomGroupAdmin, self).save_model(request, obj, form, change) 126 | 127 | if len(form.cleaned_data['permissions']) > 0: 128 | permissions = list(Permission.objects.filter( 129 | id__in=form.cleaned_data['permissions']).order_by('name')) 130 | else: 131 | permissions = [] 132 | 133 | 134 | update_permissions_group(permissions, obj) 135 | 136 | try: 137 | admin.site.unregister(User) 138 | except NotRegistered: 139 | pass 140 | 141 | try: 142 | admin.site.unregister(Group) 143 | except NotRegistered: 144 | pass 145 | 146 | admin.site.register(User, NonrelPermissionCustomUserAdmin) 147 | admin.site.register(Permission, PermissionAdmin) 148 | admin.site.register(Group, CustomGroupAdmin) 149 | -------------------------------------------------------------------------------- /permission_backend_nonrel/backends.py: -------------------------------------------------------------------------------- 1 | from django.contrib.auth.backends import ModelBackend 2 | from django.contrib.auth.models import Group 3 | 4 | from models import UserPermissionList, GroupPermissionList 5 | 6 | 7 | class NonrelPermissionBackend(ModelBackend): 8 | """ 9 | Implements Django's permission system on Django-Nonrel 10 | """ 11 | supports_object_permissions = False 12 | supports_anonymous_user = True 13 | 14 | def get_group_permissions(self, user_obj, obj=None, user_perm_list=None): 15 | """ 16 | Returns a set of permission strings that this user has through his/her 17 | groups. 18 | """ 19 | if user_obj.is_anonymous() or obj is not None: 20 | return set() 21 | if not hasattr(user_obj, '_group_perm_cache'): 22 | perms = set([]) 23 | if not user_perm_list: 24 | user_perm_list, _ = UserPermissionList.objects.get_or_create(user=user_obj) 25 | groups = Group.objects.filter(id__in=user_perm_list.group_fk_list) 26 | group_perm_lists = GroupPermissionList.objects.filter(group__in=list(groups)) 27 | 28 | for group_perm_list in group_perm_lists: 29 | perms.update(group_perm_list.permission_list) 30 | 31 | user_obj._group_perm_cache = perms 32 | return user_obj._group_perm_cache 33 | 34 | def get_all_permissions(self, user_obj, obj=None): 35 | if user_obj.is_anonymous() or obj is not None: 36 | return set() 37 | if not hasattr(user_obj, '_perm_cache'): 38 | try: 39 | user_perm_list = UserPermissionList.objects.get(user=user_obj) 40 | user_obj._perm_cache = set(user_perm_list.permission_list) 41 | 42 | except UserPermissionList.DoesNotExist: 43 | user_perm_list = None 44 | user_obj._perm_cache = set() 45 | 46 | user_obj._perm_cache.update(self.get_group_permissions(user_obj, user_perm_list=user_perm_list)) 47 | return user_obj._perm_cache 48 | -------------------------------------------------------------------------------- /permission_backend_nonrel/models.py: -------------------------------------------------------------------------------- 1 | from django.contrib.auth.models import Group 2 | from django.db import models 3 | 4 | from djangotoolbox.fields import ListField 5 | 6 | from django.contrib.auth import get_user_model 7 | User = get_user_model() 8 | 9 | 10 | class UserPermissionList(models.Model): 11 | user = models.ForeignKey(User) 12 | 13 | permission_list = ListField(models.CharField(max_length=64)) 14 | permission_fk_list = ListField(models.CharField(max_length=32)) 15 | 16 | group_fk_list = ListField(models.CharField(max_length=32)) 17 | 18 | 19 | class GroupPermissionList(models.Model): 20 | group = models.ForeignKey(Group) 21 | permission_list = ListField(models.CharField(max_length=64)) 22 | permission_fk_list = ListField(models.CharField(max_length=32)) 23 | -------------------------------------------------------------------------------- /permission_backend_nonrel/tests.py: -------------------------------------------------------------------------------- 1 | from django.conf import settings 2 | from django.contrib.auth import authenticate 3 | from django.contrib.auth.models import Group, Permission, AnonymousUser 4 | from django.contrib.contenttypes.models import ContentType 5 | from django.test import TestCase 6 | 7 | from django.contrib.auth import get_user_model 8 | User = get_user_model() 9 | 10 | from .models import UserPermissionList, \ 11 | GroupPermissionList 12 | from .utils import add_permission_to_user, \ 13 | add_user_to_group, add_permission_to_group, update_permissions_user, update_user_groups, update_permissions_group 14 | 15 | 16 | class BackendTest(TestCase): 17 | def setUp(self): 18 | self.old_auth_backends = settings.AUTHENTICATION_BACKENDS 19 | settings.AUTHENTICATION_BACKENDS = ( 20 | 'permission_backend_nonrel.backends.NonrelPermissionBackend', 21 | ) 22 | User.objects.create_user('test', 'test@example.com', 'test') 23 | 24 | def tearDown(self): 25 | settings.AUTHENTICATION_BACKENDS = self.old_auth_backends 26 | 27 | def test_update_permissions_user(self): 28 | content_type = ContentType.objects.get_for_model(User) 29 | perm = Permission.objects.create(name='test', 30 | content_type=content_type, 31 | codename='test') 32 | user = User.objects.get(username='test') 33 | self.assertEqual(user.has_perm('auth.test'), False) 34 | user = User.objects.get(username='test') 35 | 36 | # add a permission 37 | update_permissions_user([perm], user) 38 | self.assertEqual(UserPermissionList.objects.count(), 1) 39 | pl = UserPermissionList.objects.all()[0] 40 | self.assertEqual(pl.permission_list , ['%s.%s'%(perm.content_type.app_label, perm.codename)]) 41 | self.assertEqual(user.has_perm('auth.test'), True) 42 | self.assertEqual(user.has_perm('auth.test23x'), False) 43 | 44 | # add a duplicated permission 45 | user = User.objects.get(username='test') 46 | update_permissions_user([perm], user) 47 | self.assertEqual(UserPermissionList.objects.count(), 1) 48 | pl = UserPermissionList.objects.all()[0] 49 | self.assertEqual(pl.permission_list , ['%s.%s'%(perm.content_type.app_label, perm.codename)]) 50 | 51 | # add a list of permissions 52 | perm1 = Permission.objects.create(name='test1', 53 | content_type=content_type, 54 | codename='test1') 55 | perm2 = Permission.objects.create(name='test2', 56 | content_type=content_type, 57 | codename='test2') 58 | 59 | user = User.objects.get(username='test') 60 | self.assertEqual(user.has_perm('auth.test1'), False) 61 | self.assertEqual(user.has_perm('auth.test2'), False) 62 | user = User.objects.get(username='test') 63 | update_permissions_user([perm1, perm2, perm], user) 64 | self.assertEqual(user.has_perm('auth.test1'), True) 65 | self.assertEqual(user.has_perm('auth.test2'), True) 66 | self.assertEqual(user.has_perm('auth.test'), True) 67 | self.assertEqual(user.has_perm('auth.test23x'), False) 68 | 69 | 70 | user = User.objects.get(username='test') 71 | pl = UserPermissionList.objects.all()[0] 72 | update_permissions_user([perm], user) 73 | self.assertEqual(user.has_perm('auth.test1'), False) 74 | self.assertEqual(user.has_perm('auth.test2'), False) 75 | self.assertEqual(user.has_perm('auth.test'), True) 76 | self.assertEqual(user.has_perm('auth.test23x'), False) 77 | 78 | # remove all permissions 79 | user = User.objects.get(username='test') 80 | update_permissions_user([], user) 81 | self.assertEqual(UserPermissionList.objects.count(), 1) 82 | pl = UserPermissionList.objects.all()[0] 83 | self.assertEqual(pl.permission_list , []) 84 | self.assertEqual(user.has_perm('auth.test'), False) 85 | self.assertEqual(user.has_perm('auth.test1'), False) 86 | self.assertEqual(user.has_perm('auth.test2'), False) 87 | 88 | 89 | def test_add_user_to_group(self): 90 | user = User.objects.get(username='test') 91 | group = Group.objects.create(name='test_group') 92 | update_user_groups(user, [group]) 93 | self.assertEqual(UserPermissionList.objects.count(), 1) 94 | self.assertNotEqual(UserPermissionList.objects.all()[0] , None) 95 | 96 | 97 | def test_update_permissions_group(self): 98 | content_type = ContentType.objects.get_for_model(Group) 99 | perm = Permission.objects.create(name='test', 100 | content_type=content_type, 101 | codename='test') 102 | user = User.objects.get(username='test') 103 | self.assertEqual(user.has_perm('auth.test'), False) 104 | user = User.objects.get(username='test') 105 | group = Group.objects.create(name='test_group') 106 | add_user_to_group(user, group) 107 | update_permissions_group([perm], group) 108 | self.assertEqual(GroupPermissionList.objects.count(), 1) 109 | gl = GroupPermissionList.objects.all()[0] 110 | self.assertEqual(gl.permission_list , ['%s.%s'%(perm.content_type.app_label, perm.codename)]) 111 | self.assertEqual(user.has_perm('auth.test'), True) 112 | self.assertEqual(user.has_perm('auth.test2312'), False) 113 | 114 | group1= Group.objects.create(name='test_group1') 115 | perm1 = Permission.objects.create(name='test1', 116 | content_type=content_type, 117 | codename='test1') 118 | 119 | add_user_to_group(user, group1) 120 | update_permissions_group([perm1], group1) 121 | user = User.objects.get(username='test') 122 | self.assertEqual(user.has_perm('auth.test'), True) 123 | self.assertEqual(user.has_perm('auth.test1'), True) 124 | 125 | update_permissions_group([], group1) 126 | group_list = UserPermissionList.objects.filter(group_fk_list=group1.id) 127 | user = User.objects.get(username='test') 128 | self.assertEqual(user.has_perm('auth.test'), True) 129 | self.assertEqual(user.has_perm('auth.test1'), False) 130 | 131 | update_user_groups(user, [group1]) 132 | user = User.objects.get(username='test') 133 | self.assertEqual(user.has_perm('auth.test'), False) 134 | self.assertEqual(user.has_perm('auth.test1'), False) 135 | 136 | def test_has_perm(self): 137 | user = User.objects.get(username='test') 138 | self.assertEqual(user.has_perm('auth.test'), False) 139 | user.is_staff = True 140 | user.save() 141 | self.assertEqual(user.has_perm('auth.test'), False) 142 | user.is_superuser = True 143 | user.save() 144 | self.assertEqual(user.has_perm('auth.test'), True) 145 | user.is_staff = False 146 | user.is_superuser = False 147 | user.save() 148 | self.assertEqual(user.has_perm('auth.test'), False) 149 | user.is_staff = True 150 | user.is_superuser = True 151 | user.is_active = False 152 | user.save() 153 | self.assertEqual(user.has_perm('auth.test'), False) 154 | 155 | def test_custom_perms(self): 156 | user = User.objects.get(username='test') 157 | content_type = ContentType.objects.get_for_model(Permission) 158 | perm = Permission.objects.create(name='test', 159 | content_type=content_type, 160 | codename='test') 161 | # default django way (ManyToManyField) 162 | #user.user_permissions.add(perm) 163 | 164 | add_permission_to_user(perm, user) 165 | 166 | # reloading user to purge the _perm_cache 167 | user = User.objects.get(username='test') 168 | self.assertEqual(user.get_all_permissions() == set([u'auth.test']), True) 169 | self.assertEqual(user.get_group_permissions(), set([])) 170 | self.assertEqual(user.has_module_perms('Group'), False) 171 | self.assertEqual(user.has_module_perms('auth'), True) 172 | 173 | perm = Permission.objects.create(name='test2', 174 | content_type=content_type, 175 | codename='test2') 176 | 177 | # default django way (ManyToManyField) 178 | #user.user_permissions.add(perm) 179 | 180 | add_permission_to_user(perm, user) 181 | 182 | perm = Permission.objects.create(name='test3', 183 | content_type=content_type, 184 | codename='test3') 185 | 186 | # default django way (ManyToManyField) 187 | #user.user_permissions.add(perm) 188 | 189 | add_permission_to_user(perm, user) 190 | 191 | user = User.objects.get(username='test') 192 | self.assertEqual(user.get_all_permissions(), 193 | set([u'auth.test2', u'auth.test', u'auth.test3'])) 194 | self.assertEqual(user.has_perm('test'), False) 195 | self.assertEqual(user.has_perm('auth.test'), True) 196 | self.assertEqual(user.has_perms(['auth.test2', 'auth.test3']), True) 197 | 198 | perm = Permission.objects.create(name='test_group', 199 | content_type=content_type, 200 | codename='test_group') 201 | group = Group.objects.create(name='test_group') 202 | 203 | # default django way (ManyToManyField) 204 | #group.permissions.add(perm) 205 | 206 | add_permission_to_group(perm, group) 207 | 208 | # default django way (ManyToManyField) 209 | #user.groups.add(group) 210 | 211 | add_user_to_group(user, group) 212 | 213 | user = User.objects.get(username='test') 214 | exp = set([u'auth.test2', u'auth.test', 215 | u'auth.test3', u'auth.test_group']) 216 | self.assertEqual(user.get_all_permissions(), exp) 217 | self.assertEqual(user.get_group_permissions(), 218 | set([u'auth.test_group'])) 219 | self.assertEqual(user.has_perms(['auth.test3', 'auth.test_group']), 220 | True) 221 | 222 | user = AnonymousUser() 223 | self.assertEqual(user.has_perm('test'), False) 224 | self.assertEqual(user.has_perms(['auth.test2', 'auth.test3']), False) 225 | 226 | def test_has_no_object_perm(self): 227 | """Regressiontest for #12462""" 228 | 229 | user = User.objects.get(username='test') 230 | content_type = ContentType.objects.get_for_model(Group) 231 | content_type.save() 232 | perm = Permission.objects.create(name='test', 233 | content_type=content_type, 234 | codename='test') 235 | 236 | # default django way (ManyToManyField) 237 | #user.user_permissions.add(perm) 238 | 239 | add_permission_to_user(perm, user) 240 | 241 | self.assertEqual(user.has_perm('auth.test', 'object'), False) 242 | self.assertEqual(user.get_all_permissions('object'), set([])) 243 | self.assertEqual(user.has_perm('auth.test'), True) 244 | self.assertEqual(user.get_all_permissions(), set(['auth.test'])) 245 | 246 | def test_authenticate(self): 247 | user = User.objects.get(username='test') 248 | self.assertEquals(authenticate(username='test', password='test'), user) 249 | self.assertEquals(authenticate(username='test', password='testNones'), 250 | None) 251 | -------------------------------------------------------------------------------- /permission_backend_nonrel/utils.py: -------------------------------------------------------------------------------- 1 | from copy import copy 2 | 3 | from .models import UserPermissionList, GroupPermissionList 4 | 5 | 6 | def add_perm_to(obj, list_cls, filter): 7 | obj_list, created = list_cls.objects.get_or_create(**filter) 8 | obj_list.permission_list.append('%s.%s' % (obj.content_type.app_label,\ 9 | obj.codename)) 10 | obj_list.permission_fk_list.append(obj.id) 11 | obj_list.save() 12 | 13 | def add_permission_to_user(perm, user): 14 | add_perm_to(perm, UserPermissionList, {'user': user }) 15 | 16 | def add_user_to_group(user, group): 17 | obj_list, created = UserPermissionList.objects.get_or_create(user=user) 18 | obj_list.group_fk_list.append(group.id) 19 | obj_list.save() 20 | 21 | def add_permission_to_group(perm, group): 22 | add_perm_to(perm, GroupPermissionList, {'group': group}) 23 | 24 | def update_list(perm_objs, list_cls, filter): 25 | """ 26 | updates a list of permissions 27 | list_cls can be GroupPermissionList or UserPermissionList 28 | """ 29 | 30 | list_obj, created = list_cls.objects.get_or_create(**filter) 31 | old_perms = copy(list_obj.permission_list) 32 | 33 | perm_strs = ['%s.%s' % (perm.content_type.app_label, perm.codename) \ 34 | for perm in perm_objs] 35 | perm_ids = [perm.id for perm in perm_objs] 36 | 37 | for perm in old_perms: 38 | try: 39 | perm_strs.index(perm) 40 | except ValueError: 41 | i = list_obj.permission_list.index(perm) 42 | list_obj.permission_list.pop(i) 43 | list_obj.permission_fk_list.pop(i) 44 | 45 | i = 0 46 | for perm in perm_strs: 47 | try: 48 | old_perms.index(perm) 49 | except ValueError: 50 | list_obj.permission_list.append(perm) 51 | list_obj.permission_fk_list.append(perm_ids[i]) 52 | i += 1 53 | 54 | list_obj.save() 55 | 56 | def update_permissions_user(perms, user): 57 | update_list(perms, UserPermissionList, {'user': user}) 58 | 59 | def update_permissions_group(perms, group): 60 | update_list(perms, GroupPermissionList, {'group': group}) 61 | 62 | def update_user_groups(user, groups): 63 | new_group_ids = [ group.id for group in groups] 64 | pl, created = UserPermissionList.objects.get_or_create(user=user) 65 | old_group_ids = copy(pl.group_fk_list) 66 | 67 | for group_id in old_group_ids: 68 | try: 69 | new_group_ids.index(group_id) 70 | except ValueError: 71 | pl.group_fk_list.remove(group_id) 72 | 73 | for group_id in new_group_ids: 74 | try: 75 | old_group_ids.index(group_id) 76 | except ValueError: 77 | pl.group_fk_list.append(group_id) 78 | 79 | pl.save() 80 | -------------------------------------------------------------------------------- /setup.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | 3 | from setuptools import setup, find_packages 4 | 5 | CLASSIFIERS = [ 6 | 'Intended Audience :: Developers', 7 | 'Programming Language :: Python', 8 | 'Topic :: Internet', 9 | 'Topic :: Database', 10 | 'Topic :: Software Development :: Libraries :: Python Modules', 11 | 'Operating System :: OS Independent', 12 | ] 13 | 14 | for ver in ['2', '2.4', '2.5', '2.6', '2.7']: 15 | CLASSIFIERS.append('Programming Language :: Python :: %s' % ver) 16 | 17 | setup( 18 | name='permission-backend-nonrel', 19 | version='0.2', 20 | description='Django-nonrel authentication backend to support permissions and groups', 21 | packages=find_packages(exclude=('tests','tests.*')), 22 | author='Florian Hahn', 23 | author_email='flo@fhahn.com', 24 | url='https://github.com/django-nonrel/django-permission-backend-nonrel', 25 | platforms=['any'], 26 | include_package_data=True, 27 | classifiers=CLASSIFIERS 28 | ) 29 | --------------------------------------------------------------------------------