Роли пользователей в Django

Я взял на себя труд создать проект, чтобы иметь возможность формировать ваш случай, который, кстати, я нахожу довольно интересным, поскольку не исключено, что я наткнусь на что-то подобное через несколько месяцев для проекта.

Я создал проект hospital(это первое, что пришло в голову) с помощью Django 1.9. Теперь да, как сказал Джек Потрошитель, давайте по частям .

По поводу вашего комментария:

Пользователей в приложении может создавать только системный администратор и никто другой.

Это, на мой взгляд, немного облегчает вам задачу, вы забываете об утомительных регистрациях, вы создаете своего суперпользователя (с createsuperuser), а затем создаете необходимых системных пользователей и, самое главное, вы (я предполагаю, что вы системный администратор) вы будете контролировать, кто что может делать. Я также предполагаю, что вы не хотите, чтобы вас беспокоили каждый раз, когда они хотят создать пользователя, поэтому вы будете давать инструменты другим пользователям с меньшими привилегиями, чтобы они могли создавать новых пациентов и даже врачей и физиотерапевтов, что-то вроде «супер доктор".

Помните, что аутентификация (пользователи, пароли) и авторизация (группы, разрешения) — это проблемы, которые мы должны решать отдельно.

Сказав это, мы можем начать с проблемы нескольких пользователей. Я был бы склонен работать с вашей первоначальной идеей, расширить a, Userчтобы иметь логические значения и обрабатывать три типа профилей для каждого из них, я думаю, что с этим будет проще справиться, когда вы хотите войти в часть авторизации и добавить, например, пользователя doctorв группу fisioterapeutaили paciente.

Каждая группа будет иметь свои привилегии, и пользователь может принадлежать к одной или нескольким группам, например, у вас может быть врач, который также является пациентом.

Теперь да, давайте перейдем к некоторому коду. Начну с противоречия вашему утверждению:

Предыдущий, я думаю, это подход, который позволил бы мне делать то, что я ищу, только в том, что есть деталь, а именно то, что модель аутентификации Django по умолчанию не может быть изменена, она неизменна, я думаю, что изменить это вам пришлось бы модифицировать ядро ​​Джанго а это что-то более дорогое или нужно было бы сделать это хорошо или знать что делается.

Ну, это не неизменно. Вы можете выбрать между использованием AbstractBaseUser или AbstractUser, разница в том, что это AbstractBaseUserпользователь без полей Django, но он содержит всю логику аутентификации, при этом у него AbstractUserесть все поля, которые вам дает Django. Что мы будем делать, так это расширять пользователя , так как мы не хотим создавать нашу собственную модель пользователя, но мы хотим добавить несколько логических полей.

Во-первых, мы сообщаем Django, что хотим использовать нашу собственную пользовательскую модель (я создал одно приложение под названием usuario):

# settings.py

...

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'usuario'
]

...

AUTH_USER_MODEL = 'usuario.User'

Индивидуальная модель. Чтобы не чувствовать себя слишком плохо, я использую то же имя таблицы, что и Django ( auth_user):

# usuario/models.py
from __future__ import unicode_literals

from django.contrib.auth.models import AbstractUser
from django.db import models


class User(AbstractUser):
    is_medical = models.BooleanField(default=False)
    is_physiotherapist = models.BooleanField(default=False)
    is_patient = models.BooleanField(default=False)

    class Meta:
        db_table = 'auth_user'

Затем сам Django предлагает, чтобы первое, что вы делаете при расширении пользователя, — это создание миграции, поэтому мы запускаем команду, а также попутно создаем суперпользователя:

$ python manage.py makemigrations
Migrations for 'usuario':
  0001_initial.py:
    - Create model User
$ python manage.py migrate
...
$ python manage.py createsuperuser
...

С помощью быстрого запроса shellмы можем увидеть новые поля:

$ python manage.py shell
>>> from usuario.models import User
>>> User.objects.filter(username='cesar').values('is_medical', 'is_patient', 'is_physiotherapist')
[{'is_patient': False, 'is_physiotherapist': False, 'is_medical': False}]

Как вы только что видели, вполне возможно расширить пользователя. Теперь нам нужны профили. Поскольку профили относятся только OneToOneк нашему пользователю, мы можем создать все профили, которые захотим (я создам только пару полей для каждого):

# usuario/models.py
from __future__ import unicode_literals

from django.contrib.auth.models import AbstractUser
from django.db import models


class User(AbstractUser):
    is_medical = models.BooleanField(default=False)
    is_physiotherapist = models.BooleanField(default=False)
    is_patient = models.BooleanField(default=False)

    class Meta:
        db_table = 'auth_user'


class MedicalProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    active = models.BooleanField(default=True)
    name = models.CharField(max_length=64)


class PatientProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    active = models.BooleanField(default=True)
    name = models.CharField(max_length=64)


class PhysiotherapistProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    active = models.BooleanField(default=True)
    name = models.CharField(max_length=64)

Nuevamente, creamos la migración y migramos:

$ python manage.py makemigrations
Migrations for 'usuario':
  0002_medicalprofile_patientprofile_physiotherapistprofile.py:
    - Create model MedicalProfile
    - Create model PatientProfile
    - Create model PhysiotherapistProfile
$ python manage.py migrate
...

Listo, ¡ya replicamos tu idea original!

Autenticación

Veamos si es posible autenticar el usuario. No voy crear todo un login completo, solo haremos uso de authenticate() para demostrarlo. Hagámoslo desde el shell:

$ python manage.py shell
>>> from django.contrib.auth import authenticate
>>> print authenticate(username='cesar', password='password-incorrecto')
None
>>> print authenticate(username='cesar', password='password-correcto')
<User: cesar>

Perfecto, funciona. Un dolor de cabeza menos, ya sabemos que incluso habiendo creado nuestro propio modelo de usuario heredado del User de Django, el proceso de autenticación funciona como debería. La forma en la que haces la autenticación finalmente es tarea tuya (usando el sistema de autenticación Django, OAuth2, Social Auth, etc.).

Autorización

Como mencioné anteriormente, bastará por el momento con crear tres grupos: doctor, fisioterapeuta y paciente. Antes de continuar, podemos crear algunas funciones en nuestro modelo User para obtener los perfiles de acuerdo al tipo de usuario.

# usuario/models.py
from __future__ import unicode_literals

from django.contrib.auth.models import AbstractUser
from django.db import models


class User(AbstractUser):
    is_medical = models.BooleanField(default=False)
    is_physiotherapist = models.BooleanField(default=False)
    is_patient = models.BooleanField(default=False)

    def get_medical_profile(self):
        medical_profile = None
        if hasattr(self, 'medicalprofile'):
            medical_profile = self.medicalprofile
        return medical_profile

    def get_patient_profile(self):
        patient_profile = None
        if hasattr(self, 'patientprofile'):
            patient_profile = self.patientprofile
        return patient_profile

    def get_physiotherapist_profile(self):
        physiotherapist_profile = None
        if hasattr(self, 'physiotherapistprofile'):
            physiotherapist_profile = self.physiotherapistprofile
        return physiotherapist_profile

    class Meta:
        db_table = 'auth_user'


class MedicalProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    active = models.BooleanField(default=True)
    name = models.CharField(max_length=64)


class PatientProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    active = models.BooleanField(default=True)
    name = models.CharField(max_length=64)


class PhysiotherapistProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    active = models.BooleanField(default=True)
    name = models.CharField(max_length=64)

Esto nos ayudará, ya que cuando usas la relación OneToOneField y esta relación no existe, te genera el error RelatedObjectDoesNotExist:

$ python manage.py shell
>>> from usuario.models import User
>>> usuario = User.objects.get(username='cesar')
>>> usuario.medicalprofile
Traceback (most recent call last):
  File "<console>", line 1, in <module>
  File "/home/cesar/Development/Personal/hospital/venv/local/lib/python2.7/site-packages/django/db/models/fields/related_descriptors.py", line 355, in __get__
    self.related.get_accessor_name()
RelatedObjectDoesNotExist: User has no medicalprofile.

Pero, si usamos nuestra nuevas funciones, no generará error porque estamos validando previamente que existe el atributo:

>>> print usuario.get_medical_profile()
None

Muy bien, entonces estas funciones nos servirán de mucho. Como ejemplo, en alguna de tus vistas podrías usarlas de esta forma para obtener los perfiles de acuerdo al usuario logueado:

def crear_historia_clinica(request):
    user = request.user
    if user.is_medical:
        profile = user.get_medical_profile()
        # Tal vez el doctor es nuevo y no tiene perfil
        if profile:
            # Mas código
        else:
            # Redireccionar, levantar un error, etc.
    else:
        # Redireccionar, levantar un error, etc.

Bien, para ver el tema de los grupos, creemos solo un doctor y un paciente: "Dr. House" y "Jorge Enfermizo". No quiero llenar esto de capturas de pantalla ya que esto es fácil de hacer desde el admin, pero hagámoslo desde el shell:

$ python manage.py shell
>>> from usuario.models import User
>>> User.objects.create_user(username='Dr. House', password='12345', is_medical=True)
<User: Dr. House>
>>> User.objects.create_user(username='Jorge Enfermizo', password='67890', is_patient=True)
<User: Jorge Enfermizo>
>>> User.objects.all()
[<User: cesar>, <User: Jorge Enfermizo>, <User: Dr. House>]

Listo, ahora creemos los grupos de los usuarios:

>>> from django.contrib.auth.models import Group
>>> Group.objects.create(name='doctor')
<Group: doctor>
>>> Group.objects.create(name='fisioterapeuta')
<Group: fisioterapeuta>
>>> Group.objects.create(name='paciente')
<Group: paciente>
>>> Group.objects.all()
[<Group: doctor>, <Group: fisioterapeuta>, <Group: paciente>]

Agregamos los usuarios a su grupo correspondiente, digamos que Dr. House también puede ser un paciente:

>>> grupo_doctor = Group.objects.get(name='doctor')
>>> grupo_paciente = Group.objects.get(name='paciente')
>>> doctor_house = User.objects.get(username='Dr. House')
>>> doctor_house.groups.add(grupo_doctor, grupo_paciente)
>>> doctor_house.groups.all()
[<Group: doctor>, <Group: paciente>]
>>> jorge_enfermizo = User.objects.get(username='Jorge Enfermizo')
>>> jorge_enfermizo.groups.add(grupo_paciente)
>>> jorge_enfermizo.groups.all()
[<Group: paciente>]

Ahora, solo bastará con preguntar para saber si un usuario pertenece a cierto grupo, en algunas de tus vistas:

def solo_para_pacientes(request):
    user = request.user
    if user.groups.filter(name='paciente').exists():
        # Tiene los privilegios de este grupo
    else:
        # Redireccionar, levantar un error, etc.

Finalmente, solo quedaría que a los grupos creados, les agregues los permisos que quieres que tenga cada uno y en las vistas uses tus mecanismos para comprobar que el usuario pueda hacer solo lo que su grupo le permite.

Notas finales

Siempre lo digo, no reinventes la rueda a menos que sea por temas didácticos.

Si quieres autenticar usuarios:

• django-oauth-toolkit
• python-social-auth

Si quieres validar la parte de autorización:

• django-braces
• django-guardian

Si se te antoja usar registro de usuarios:

• django-registration
• django-registration-redux

Si quieres un template gratuito, actualizado y muy bueno:

• AdminLTE

Es muy interesante tu caso de uso, probé una solución un poco mas sencilla, no estoy seguro si cumple a cabalidad con tus requerimientos, en esta solución se puede usar django.contrib sin complicaciones para login y demás.

Eso sí agregando cada usuario a un grupo de usuarios de Django para posteriores filtros en los views, un usuario puede pertenecer a N grupos sin problemas, desde el sitio de administración puedes asignar a los usuarios a determinados grupos.

Perdón por la informalidad del código, pero es una vista global de como se puede construir la base de datos, los atributos son valores de pruebas.

models.py

from django.db import models
from django.contrib.auth.models import User 


class Medico(models.Model):
    especialidad = models.CharField(max_length=120)
    usuariomedico = models.OneToOneField(User, unique=True)

class Fisioterapeuta(models.Model):
    direccion = models.CharField(max_length=120)
    usuariofisio = models.OneToOneField(User, unique=True)

class Paciente(models.Model):
     usuariopaciente = models.OneToOneField(User, unique=True)

class PacienteEspecializado(models.Model):
    nombre = models.CharField(max_length=120)
    usuario = models.OneToOneField(Paciente, to_field='usuariopaciente', null=True,blank=True)  
    medico = models.OneToOneField(Medico, to_field='usuariomedico', null=True,blank=True)
    fisioterapeuta = models.OneToOneField(Fisioterapeuta, to_field='usuariofisio', null=True,blank=True)

Se me viene a la cabeza que la clase PacienteEspecializado puede ser una historia clínica o cualquier otra cosa.

Al registrarlos en admin.py, el código sobra pero bueno.

admin.py

from django.contrib import admin
from .models import Medico, Fisioterapeuta, Paciente, PacienteEspecializado


admin.site.register(Medico)
admin.site.register(Fisioterapeuta)
admin.site.register(Paciente)
admin.site.register(PacienteEspecializado)

Si tienes alguna pregunta o la solución tiene algún error házmelo saber.

Un saludo amigo. Yo uso un enfoque similar al tuyo, creando grupos de usuarios en Groups de Django. Extendiendo el modelo con un modelo "Usuario" y un FK hacia User (Todos mis roles requieren los mismos campos).

class Usuario(models.Model):
        user = models.OneToOneField(User, on_delete=models.CASCADE, related_name='usuario')
        ci_ruc = models.CharField(max_length= 13, help_text='Cedula o RUC')
        direccion = models.CharField(max_length= 200)
        telefono = models.CharField(max_length=20)
        ciudad = models.CharField(max_length=50, default='Loja')
        empresa = models.ForeignKey(Empresa, blank=True, null=True)
        tecnico_externo = models.BooleanField(default=False, help_text='Técnico que no trabaja en la empresa. Se contrata por servicios específicos.')

        def __str__(self):
            return self.user.username

    @receiver(post_save, sender=User)
    def create_user_profile(sender, instance, created, **kwargs):
        if created:
            Usuario.objects.create(user=instance)

    @receiver(post_save, sender=User)
    def save_user_profile(sender, instance, **kwargs):
        instance.usuario.save()

Las ultimas funciones aseguran que la creación de un "Usuario" se relacione directamente con la creación de un "User". Lo hice siguiendo este tutorial: https://simpleisbetterthancomplex.com/tutorial/2016/07/22/how-to-extend-django-user-model.html#onetoone

Otra recomendación es que protejas los templates. No sé que tan recomendable sea puesto que no he hecho protección desde las vistas. Yo he agregado un templatetag en la app usuarios:

Este es el código de user_tags.py:

# -*- coding:utf-8 -*-
from __future__ import unicode_literals

# Stdlib imports

# Core Django imports
from django import template

# Third-party app imports

# Realative imports of the 'app-name' package


register = template.Library()


@register.filter('has_group')
def has_group(user, group_name):
    """
    Verifica se este usuário pertence a um grupo
    """
    groups = user.groups.all().values_list('name', flat=True)
    return True if group_name in groups else False

Luego simplemente la cargas con "load" en tu template. https://docs.djangoproject.com/en/2.1/howto/custom-template-tags/

 <ul class="nav side-menu">
      {% if user|has_group:"Clientes" %}
         <!-- REPARACIONES -->
        <li><a><i class="fa fa-bug"></i> Reparaciones <span class="fa fa-chevron-down"></span></a>
          <ul class="nav child_menu">
            <li><a href="{% url 'reparaciones:list_user' user.pk %}">Mis equipos</a></li>
          </ul>
        </li>
      {% else %}

Ahora, tu app es requerida para un sólo un hospital. Mi problema surgió cuando un usuario tiene varios roles en varias empresas, es decir, es técnico en una y cliente en otra, en ese caso se actualizó el fk hacia empresa, y ahora tiene las reparaciones de la empresa en la que es cliente.

Estoy en este dilema, necesitaría extender la tabla

auth_user_group

y añadir empresa_id. Así podría seleccionar a que empresa pertenece el rol en el que se está desempeñando, y al estar los templates protegidos no tendría acceso a ciertas vistas. Espero te sirva y te dejo el enfoque, por si tu app crece y la requieras utilizar en múltiples hospitales, y te evites este quebradero de cabeza en el que estoy.

Ознакомьтесь с этим руководством, если оно поможет: https://simpleisbetterthancomplex.com/tutorial/2018/01/18/how-to-implement-multiple-user-types-with-django.html

Удачи и программирования!