Django 中的用户角色

我不厌其烦地创建了一个能够塑造你的案例的项目，顺便说一句，我觉得这很有趣，因为我可能会在几个月内遇到类似的项目。

我使用 Django 1.9 创建了这个项目hospital（这是我首先想到的）。现在是的，正如开膛手杰克所说，让我们分部分进行。

关于您的评论：

应用程序中的用户只能由系统管理员创建，其他人不得创建。

在我看来，这让你的事情变得更容易了，你忘记了繁琐的注册，你将创建你的超级用户（使用createsuperuser），然后创建必要的系统用户，最重要的是，你（我假设你是系统管理员）您将成为控制谁可以做什么的人。我还假设您不想每次创建用户时都被打扰，因此您会将工具提供给其他权限较少的用户，以便能够创建新患者甚至医生和物理治疗师，就像“超级医生”。

请记住，身份验证（用户、密码）和授权（组、权限）是我们必须单独解决的问题。

话虽如此，我们可以从多用户的问题开始。我倾向于使用您的原始想法，扩展 aUser以具有布尔值并为每种类型处理三种类型的配置文件，我认为当您想要输入授权部分并添加例如用户时，这将更容易处理到组doctor，fisioterapeuta或paciente。

每个组都有其权限，并且用户可能属于一个或多个组，因此您可以拥有一位同时也是患者的医生。

现在是的，让我们来看一些代码。我将首先反驳你的说法：

上一个，我认为这是一种可以让我做我正在寻找的事情的方法，只是有一个细节，那就是 Django 的默认身份验证模型不能修改，它是不可变的，我认为要修改如果你必须修改 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

祝你好运和编程！