Yo 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 así:
- Al usuario se le asignará un rol (administrador, invitado, personal, público)
- Un rol tendrá uno o varios permisos asignados (user_write, user_modify, report_read), etc.
- El permiso para el Usuario se heredará del rol al que pertenece
- Se puede asignar al usuario un permiso manual además del permiso heredado del rol.
Para hacer esto, se me ocurrió el siguiente diseño de base de datos.
role
I store the role name here
+----------+
| Field |
+----------+
| id |
| role_name |
+----------+
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 |
| permission_name |
| permission_key |
+----------------+
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 el ACL. Puedo permitir que los superadministradores asignen permisos por sí mismos, y así sucesivamente. Como dije, esto es solo para darte una idea.
