Eu faria assim.
table name: permission
columns: id, permission_name
e então posso atribuir várias permissões ao usuário usando uma tabela de relacionamento muitos para muitos
table name: user_permission
columns: permission_id, user_id
Este design me permitirá adicionar quantas permissões eu quiser e atribuí-las a quantos usuários eu quiser.
Embora o design acima atenda às suas necessidades, tenho meu próprio método de implementação de ACL em meu aplicativo. Estou postando aqui.
Meu método de implementação da ACL é assim:
- O usuário receberá uma função (Administrador, convidado, equipe, público)
- Uma função terá uma ou várias permissões atribuídas a ela (user_write, user_modify, report_read) etc.
- A permissão para o usuário será herdada da função a que ele pertence
- O usuário pode receber permissão manual além da permissão herdada da função.
Para fazer isso, criei o seguinte design de banco de dados.
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 |
+---------------+
Isso me dá mais controle sobre a ACL. Posso permitir que superadministradores atribuam permissão por conta própria e assim por diante. Como eu disse isso é só para dar uma ideia.
