php - usar - Almacenamiento de permisos de aplicaciones en una base de datos

permisos gps android studio

Question

Estoy desarrollando una aplicación para nuestra empresa que finalmente tendrá muchas formas de restringir a los usuarios a secciones / módulos particulares. Si bien la aplicación aún es pequeña, me gustaría pasar a un nuevo método de almacenamiento de permisos que, a medida que la aplicación crece, seguirá siendo fácil de mantener y consultar.

Actualmente en nuestra base de datos MySQL tenemos una tabla llamada "usuario" que almacena la identificación del usuario, nombre de usuario y contraseña. En una tabla separada llamada "user_acl" es la siguiente:

user_acl_id
acl_root
acl_news_read
acl_news_write
acl_news_modify
acl_reports_read
acl_reports_write
acl_reports_modify
acl_users_read
acl_users_write
acl_users_modify

Solo tenemos 3 módulos por minuto, pero con el tiempo se crearán más y se necesitarán agregar permisos para cada uno.

En lugar de crear una columna para cada permiso, ¿hay alguna otra forma de almacenar esta información?

Answer 1

Creo que deberías tener tablas favoritas

user
user_x_profile
profile
profile_x_function
function

Configura varios perfiles "genéricos", "visor", "empleado", "gerente", etc.

Configura una entrada de "función" para cada objeto que desea controlar.

Luego, vincule las funciones a los perfiles en profile_x_function.

Luego asigne uno o más perfiles a cada usuario.

Esto reduce el esfuerzo de la administración. Supongamos que desea agregar otra función que solo puedan usar los "gerentes": simplemente agrega una nueva entrada en la tabla de funciones y luego agrega una entrada en la tabla "profile_x_function" que vincula el perfil "manager" con el permiso del perfil del administrador y está disponible para todos los gerentes.

Para consultar el acceso, necesitará una unión de cinco tablas, pero solo está seleccionando un atributo de permision.

Answer 2

Lo haría de esta manera.

table name: permission
columns: id, permission_name

y luego puedo asignar múltiples permisos al usuario usando una tabla de relaciones de muchos a muchos

table name: user_permission
columns: permission_id, user_id

Este diseño me permitirá agregar tantos permisos como quiera y asignarlos a tantos usuarios como quiera.

Si bien el diseño anterior cumple con sus requisitos, tengo mi propio método para implementar ACL en mi aplicación. Lo estoy publicando aquí.

Mi método de implementación de ACL es el siguiente:

1. Al usuario se le asignará un rol (administrador, invitado, personal, público)
2. Un rol tendrá uno o más permisos asignados (user_write, user_modify, report_read) etc.
3. El permiso para el usuario se heredará de la función a la que pertenece
4. Al usuario se le puede asignar un permiso manual además del permiso heredado de la función.

Para hacer esto, he creado el siguiente diseño de base de datos.

role
I store the role name here 
+----------+
| Field    |
+----------+
| id       |
| roleName |
+----------+

permission:
I store the permission name and key here 
Permission name is for displaying to user.
Permission key is for determining the permission.
+----------------+
| Field          |
+----------------+
| id             |
| permissionName |
| permissionKey  |
+----------------+

role_permission
I assign permission to role here 
+---------------+
| Field         |
+---------------+
| id            |
| role_id       |
| permission_id |
+---------------+

user_role
I assign role to the user here 
+---------------+
| Field         |
+---------------+
| id            |
| user_id       |
| role_id       |
+---------------+

user_permission
I store the manual permission I may allow for the user here 
+---------------+
| Field         |
+---------------+
| id            |
| user_id       |
| permission_id |
+---------------+

Esto me da más control sobre la ACL. Puedo permitir que los superadmintos otorguen permisos por sí mismos, y así sucesivamente. Como dije, esto es solo para darte la idea.

Answer 3

Como dice Ibrahim, crea una nueva tabla específicamente para tus permisos. Asigne un valor numérico a un usuario que represente su nivel de permiso, digamos 1 = leer, 2 = escribir / leer, 3 = modificar / escribir / leer. Luego, en su código, verifique el nivel de permiso adecuado antes de permitir que un usuario realice una tarea específica. Si no tienen el valor requerido (3 para modificar o> = 2 para escribir), entonces bloqueas esa capacidad.

Answer 4

Creo que deberías hacer esos permisos en formato jSON.

puede crear otra tabla con permisos donde puede agregar, modificar, eliminar filas en cualquier momento que desee.

o

cada vez que el usuario se autentica puede almacenar esos permisos en la sesión y pasarlos a sus scripts.

Mi sugerencia personal es la primera opción.