tutorial - the django project

¿Cómo puedo MODIFICAR django para crear el permiso "ver"?

Question

Recientemente comencé a usar django para administrar una gran aplicación existente que se cultivó orgánicamente a lo largo de los años utilizando twisted.web. Comencé a experimentar con django y es una interfaz de administración automática y estoy muy satisfecho con los resultados.

Una cosa que parece faltar para mis propósitos es la capacidad de darles a los usuarios acceso de solo lectura a los datos. Por ejemplo, tenemos un rol en el que las personas pueden iniciar sesión y crear órdenes de compra. También necesitan poder ver, pero no editar, otros datos de clientes o productos.

¿Cómo crearía permisos de "vista" en el administrador de django para que los usuarios puedan modificar los datos de algunas tablas, mientras que tienen acceso de solo lectura a otras?

Actualización: Django Admin parece darme el CUD de una interfaz CRUD. ¿Cómo obtengo la parte de Solo lectura con los permisos y grupos asociados?

Actualización 2010-Feb-12: Django 1.2 ahora incluirá solo lectura. Detalles abajo.

Respondí a mi propia pregunta, supongo. Mover el contenido a una respuesta real a continuación.

Answer 1

Así es como cambié Django 1.0.2 para agregar permisos ''ver''. Lo sentimos, no hay diff disponible.

[X] 1. Se agregó ''ver'' a la lista de permisos predeterminada

#./contrib/auth/management/__init__.py
def _get_all_permissions(opts):
    "Returns (codename, name) for all permissions in the given opts."
    perms = []
    for action in (''add'', ''change'', ''delete'', ''view''):
        perms.append((_get_permission_codename(action, opts), u''Can %s %s'' % (action, opts.verbose_name_raw)))
    return perms + list(opts.permissions)

[X] 2. Probar el permiso ''ver'' se agrega a todos los modelos

run manage.py syncdb

Confirmé que el permiso de vista ahora se agrega para todas las tablas en la tabla auth_permissions

[X] 3. Agregue "get_view_permission" a la clase de modelo predeterminada.

Se agregó get_view_permission a la clase de modelo. Puede encontrar esto en el archivo ./db/models/options.py Esto es utilizado por la clase de administrador en el siguiente paso.

def get_view_permission(self):
    return ''view_%s'' % self.object_name.lower()

[X] 4. Agrega "has_view_permission" a la clase de administrador predeterminada

Para ser consistente, voy a agregar "has_view_permission" al sistema. Parece que debería estar en algún lugar en contrib / admin / options.py . Se aseguró de que si el usuario tiene permiso de modificación, los permisos de vista se impliquen automáticamente.

# /contrib/admin/options.py
# Added has_view_permissions
def has_view_permission(self, request, obj=None):
    """
    Returns True if the given request has permission to change or view
    the given Django model instance.

    If `obj` is None, this should return True if the given request has
    permission to change *any* object of the given type.
    """
    opts = self.opts
    return self.has_change_permission(request, obj) or /
        request.user.has_perm(opts.app_label + ''.'' + opts.get_view_permission())

# modified get_model_perms to include ''view'' too.
# No idea where this may be used, but trying to stay consistent
def get_model_perms(self, request):
        """
        Returns a dict of all perms for this model. This dict has the keys
        ``add``, ``change``, and ``delete`` and ``view`` mapping to the True/False
        for each of those actions.
        """
        return {
            ''add'': self.has_add_permission(request),
            ''change'': self.has_change_permission(request),
            ''delete'': self.has_delete_permission(request),
            ''view'': self.has_view_permission(request),
        }

# modified response_add function to return the user to the mode list
# if they added a unit and have view rights
... 
    else:
        self.message_user(request, msg)

        # Figure out where to redirect. If the user has change permission,
        # redirect to the change-list page for this object. Otherwise,
        # redirect to the admin index.
        #if self.has_change_permission(request, None):
        if self.has_change_permission(request, None) or self.has_view_permission(request, None):
            post_url = ''../''
        else:
            post_url = ''../../../''
        return HttpResponseRedirect(post_url)

 # modified the change_view function so it becomes the details 
 # for users with view permission

    #if not self.has_change_permission(request, obj):
    if not (self.has_change_permission(request, obj) or (self.has_view_permission(request, obj) and not request.POST)):
        raise PermissionDenied


  # modified the changelist_view function so it shows the list of items
  # if you have view permissions
def changelist_view(self, request, extra_context=None):
    "The ''change list'' admin view for this model."
    from django.contrib.admin.views.main import ChangeList, ERROR_FLAG
    opts = self.model._meta
    app_label = opts.app_label
    #if not self.has_change_permission(request, None):
    if not (self.has_change_permission(request, None) or self.has_view_permission(request, None)):
        raise PermissionDenied

[X] 5. Actualizar la plantilla predeterminada para mostrar modelos si el usuario tiene permiso de visualización

Modifiqué la plantilla predeterminada en contrib / admin / templates / admin / index.html. Esto también podría manejarse copiando el archivo en el directorio de plantillas locales. Hice cambios en ambos, así que tengo una copia si una actualización posterior sobrescribe mis cambios.

 {% for model in app.models %}
            <tr>
            {% if model.perms.change %}
                <th scope="row"><a href="{{ model.admin_url }}">{{ model.name }}</a></th>
            {% else %}
                {% if model.perms.view %}
                    <th scope="row"><a href="{{ model.admin_url }}">{{ model.name }}</a></th>
                {% else %}
                    <th scope="row">{{ model.name }}</th>
                {% endif %}
            {% endif %}

[X] 6. Confirmar que el usuario puede "ver" pero no "cambiar" el modelo

Encontrado contrib / admin / templatetags / admin_modify.py parece controlar los botones guardar / guardar y continuar apareciendo o no. Se modificó el campo "guardar" del valor predeterminado de siempre verdadero, para verificar el contexto y los permisos. El usuario debería poder guardar si tienen cambios o agrega permisos.

 ''show_save'': (change and context[''has_change_permission'']) or (context[''add''] and context[''has_add_permission''])

[X] 7. Quite el botón "Guardar y agregar otro" si el usuario está viendo un elemento

Modificado contrib / admin / templatetags / admin_modify.py nuevamente. No sé lo que significa ''save_as'', entonces quizás rompí algo, pero parece que funciona.

    #''show_save_and_add_another'': context[''has_add_permission''] and
    #                    not is_popup and (not save_as or context[''add'']) ,
    ''show_save_and_add_another'': not is_popup and
        (( change and context[''has_change_permission'']) or (context[''add''] and context[''has_add_permission'']))
        and
        (not save_as or context[''add'']),

[X] 8. Modifica el permiso de "vista" para que el formulario solo sea de lectura

Si el usuario tiene el permiso "ver" y el permiso "cambiar", entonces no haga nada. Cambiar la vista de anulaciones

Si el usuario tiene el permiso "ver" sin "cambiar", entonces cambie los formularios predeterminados y agregue los atributos DISABLED o READONLY a los elementos del formulario. No todos los navegadores admiten esto, pero para mis propósitos puedo exigir que los usuarios usen el correcto. Ejemplo de Disabled / Readonly

Se descubrió que no todos los navegadores reconocen "solo lectura", por lo que establece algunos controles de solo lectura y otros desactivados. Esto permite a los usuarios copiar datos de los controles de texto si es necesario.

#/django/contrib/admin/templates/admin/change_form.html

{# JavaScript for prepopulated fields #}
{% prepopulated_fields_js %}

</div>
</form></div>
{% if has_view_permission and not has_change_permission %}
    <script type="text/javascript">
    jQuery(''input:text'').attr(''readonly'', ''readonly'');
    jQuery(''textarea'').attr(''readonly'', ''readonly'');
    jQuery(''input:checkbox'').attr(''disabled'', true);
    jQuery(''select'').attr(''disabled'', true);
    jQuery(''.add-another'').hide();
    </script>
{% endif %}

Answer 2

Está justo allí en el administrador. Puede establecer permisos para Usuarios y Grupos en el administrador para agregar, cambiar y eliminar modelos específicos.

Actualización: Perdón, interpreté mal la pregunta porque malinterpreté la palabra vista para darle el significado de Django en lugar de "solo lectura". Si quieres solo lectura con el administrador, creo que deberás hacer un poco de trabajo. Vea este hilo , donde James Bennett (gerente de lanzamiento de Django) dice:

Como encontrará al buscar en los archivos de esta lista, esto no es algo que la interfaz de administración de Django está diseñada para admitir, por lo que cualquier solución deberá venir de usted escribiendo su propio código.

y

El administrador de Django opera con tres permisos: "agregar", "cambiar" y "eliminar". No hay permiso de "ver pero no hacer modificaciones", por lo tanto, no hay forma de aplicar dicha restricción sin hacer una codificación personalizada significativa.

El trabajo adicional implicará agregar un permiso de "solo lectura" para ciertos modelos y cambiar las plantillas de administración básicas para verificar si el usuario tiene ese permiso; de ser así, deshabilitar ciertos controles (como guardar los botones) y hacer que otros solo sean de lectura. . Eso evitará retoques casuales, pero también puede necesitar modificar la lógica del lado del servidor para verificar el mismo permiso, para evitar cualquier POST hecho de manera furtiva para eludir los permisos.

Answer 3

Este fragmento convertirá al superusuario en el único con acceso de escritura.

class AdminOwn(admin.ModelAdmin):
    def get_readonly_fields(self, request, obj=None):
        if request.user.is_superuser:
            return self.readonly_fields
        #get all fields as readonly
        fields = [f.name for f in self.model._meta.fields]
        return fields

Answer 4

La capacidad de agregar campos de solo lectura a la vista de administrador ahora se incluye en la versión 1.2 de Django.

Vea el número de ticket 342 http://code.djangoproject.com/ticket/342

Ver el conjunto de cambios número 11965 http://code.djangoproject.com/changeset/11965

Consulte la documentación http://docs.djangoproject.com/en/dev/ref/contrib/admin/#django.contrib.admin.ModelAdmin.readonly_fields

Answer 5

Puede crear grupos en el módulo de autenticación. Luego, en admin.py, basado en el inicio de sesión del grupo de usuarios, establezca el atributo readonly_fields de modeladmin. Agregue el método def has_add_permission (self, request) para devolver falso para el grupo con permiso de solo lectura. Dar el complemento, modificar los permisos para el grupo. Solo podrán leer los atributos del modelo.

Answer 6

Puede crear un permiso de "solo lectura" en su modelo y usar el código de jasuca con una modificación:

models.py:

class MyModel(models.Model):
    name = models.CharField(max_length=100)
    description = models.CharField(max_length=256, null=True, blank=True)

    class Meta:
        permissions = (
            (''readonly_mymodel'',''Readonly MyModel''),
        )

admin.py:

class MyModelAdmin(admin.ModelAdmin):
    def get_readonly_fields(self, request, obj=None):
        if not request.user.is_superuser and request.user.has_perm(''mymodel.readonly_mymodel''):
            return [f.name for f in self.model._meta.fields]
        return self.readonly_fields

En el administrador de la aplicación debe otorgar permiso de "cambio" y "solo lectura" al usuario.