Come posso utilizzare le autorizzazioni Django senza definire un tipo di contenuto o un modello?

Vorrei utilizzare un sistema basato su autorizzazioni per limitare determinate azioni all'interno della mia applicazione Django. Queste azioni non devono essere correlate a un modello particolare (ad es. Accesso alle sezioni nell'applicazione, ricerca ...), quindi non posso utilizzare direttamente il framework delle autorizzazioni stock , perché il Permissionmodello richiede un riferimento a un tipo di contenuto installato.

Potrei scrivere il mio modello di autorizzazione ma poi dovrei riscrivere tutte le chicche incluse con le autorizzazioni Django, come ad esempio:

• Possibilità di assegnare permessi a utenti e gruppi.
• Il permission_requireddecoratore .
• User.has_perm e metodi utente correlati.
• La permsvariabile del modello .
• ...

Ho controllato alcune app come django-authority e django-guardian , ma sembrano fornire autorizzazioni ancora più accoppiate al sistema modello, consentendo autorizzazioni per oggetto.

C'è un modo per riutilizzare questo quadro senza aver definito alcun modello (oltre Usere Group) per il progetto?

Il Permissionmodello di Django richiede ContentTypeun'istanza .

Penso che un modo per aggirarlo sia creare un dummy ContentTypeche non è correlato a nessun modello (i campi app_labele modelpossono essere impostati su qualsiasi valore di stringa).

Se vuoi che tutto sia pulito e piacevole, puoi creare un Permission modello proxy che gestisca tutti i dettagli orribili del manichino ContentTypee crei istanze di autorizzazione "senza modello". Puoi anche aggiungere un gestore personalizzato che filtra tutte le Permissionistanze relative ai modelli reali.

Per quelli di voi che stanno ancora cercando:

È possibile creare un modello ausiliario senza tabella di database. Quel modello può portare al tuo progetto qualsiasi autorizzazione di cui hai bisogno. Non è necessario gestire ContentType o creare oggetti Permission in modo esplicito.

from django.db import models
        
class RightsSupport(models.Model):
            
    class Meta:
        
        managed = False  # No database table creation or deletion  \
                         # operations will be performed for this model. 
                
        default_permissions = () # disable "add", "change", "delete"
                                 # and "view" default permissions

        permissions = ( 
            ('customer_rights', 'Global customer rights'),  
            ('vendor_rights', 'Global vendor rights'), 
            ('any_rights', 'Global any rights'), 
        )

Subito dopo manage.py makemigrationse manage.py migratepuoi usare questi permessi come qualsiasi altro.

# Decorator

@permission_required('app.customer_rights')
def my_search_view(request):
    …

# Inside a view

def my_search_view(request):
    request.user.has_perm('app.customer_rights')

# In a template
# The currently logged-in user’s permissions are stored in the template variable {{ perms }}

{% if perms.app.customer_rights %}
    <p>You can do any customer stuff</p>
{% endif %}

Seguendo il consiglio di Gonzalo , ho utilizzato un modello proxy e un gestore personalizzato per gestire i miei permessi "senza modello" con un tipo di contenuto fittizio.

from django.db import models
from django.contrib.auth.models import Permission
from django.contrib.contenttypes.models import ContentType


class GlobalPermissionManager(models.Manager):
    def get_query_set(self):
        return super(GlobalPermissionManager, self).\
            get_query_set().filter(content_type__name='global_permission')


class GlobalPermission(Permission):
    """A global permission, not attached to a model"""

    objects = GlobalPermissionManager()

    class Meta:
        proxy = True

    def save(self, *args, **kwargs):
        ct, created = ContentType.objects.get_or_create(
            name="global_permission", app_label=self._meta.app_label
        )
        self.content_type = ct
        super(GlobalPermission, self).save(*args, **kwargs)

Risolto il problema con la risposta di Chewie in Django 1.8, che come richiesto in alcuni commenti.

Dice nelle note di rilascio:

Il campo del nome di django.contrib.contenttypes.models.ContentType è stato rimosso da una migrazione e sostituito da una proprietà. Ciò significa che non è più possibile interrogare o filtrare un ContentType in questo campo.

Quindi è il "nome" di riferimento in ContentType che non utilizza in GlobalPermissions.

Quando lo risolvo, ottengo quanto segue:

from django.db import models
from django.contrib.auth.models import Permission
from django.contrib.contenttypes.models import ContentType


class GlobalPermissionManager(models.Manager):
    def get_queryset(self):
        return super(GlobalPermissionManager, self).\
            get_queryset().filter(content_type__model='global_permission')


class GlobalPermission(Permission):
    """A global permission, not attached to a model"""

    objects = GlobalPermissionManager()

    class Meta:
        proxy = True
        verbose_name = "global_permission"

    def save(self, *args, **kwargs):
        ct, created = ContentType.objects.get_or_create(
            model=self._meta.verbose_name, app_label=self._meta.app_label,
        )
        self.content_type = ct
        super(GlobalPermission, self).save(*args)

La classe GlobalPermissionManager è rimasta invariata ma inclusa per completezza.

Questa è una soluzione alternativa. Per prima cosa chiediti: perché non creare un modello fittizio che esiste davvero nel DB ma che non viene mai utilizzato, tranne che per mantenere i permessi? Non è bello, ma penso che sia una soluzione valida e diretta.

from django.db import models

class Permissions(models.Model):

    can_search_blue_flower = 'my_app.can_search_blue_flower'

    class Meta:
        permissions = [
            ('can_search_blue_flower', 'Allowed to search for the blue flower'),
        ]

La soluzione sopra ha il vantaggio, che puoi usare la variabile Permissions.can_search_blue_flowernel tuo codice sorgente invece di usare la stringa letterale "my_app.can_search_blue_flower". Ciò significa meno errori di battitura e più completamento automatico nell'IDE.

Puoi usare proxy modelper questo con un tipo di contenuto fittizio.

from django.contrib.auth.models import Permission
from django.contrib.contenttypes.models import ContentType


class CustomPermission(Permission):

    class Meta:
        proxy = True

    def save(self, *args, **kwargs):
        ct, created = ContentType.objects.get_or_create(
            model=self._meta.verbose_name, app_label=self._meta.app_label,
        )
        self.content_type = ct
        super(CustomPermission, self).save(*args)

Ora puoi creare l'autorizzazione con solo namee codenamel'autorizzazione dal CustomPermissionmodello.

 CustomPermission.objects.create(name='Can do something', codename='can_do_something')

E puoi interrogare e visualizzare solo le autorizzazioni personalizzate nei tuoi modelli in questo modo.

 CustomPermission.objects.filter(content_type__model='custom permission')