RBAC API

Une API plus conviviale pour RBAC. Cette API est un sous-ensemble de l'API de gestion. Les utilisateurs RBAC pourraient utiliser cette API pour simplifier le code.

Référence

La variable globale e est une instance de Enforcer.

Go

e, err := NewEnforcer("examples/rbac_model.conf", "examples/rbac_policy.csv")

Node.js

const e = await newEnforcer('examples/rbac_model.conf', 'examples/rbac_policy.csv')

PHP

$e = new Enforcer('examples/rbac_model.conf', 'examples/rbac_policy.csv');

Python

e = casbin.Enforcer("examples/rbac_model.conf", "examples/rbac_policy.csv")

.NET

var e = new Enforcer("path/to/model.conf", "path/to/policy.csv");

Rust

let mut e = Enforcer::new("examples/rbac_model.conf", "examples/rbac_policy.csv").await?;

Java

Enforcer e = new Enforcer("examples/rbac_model.conf", "examples/rbac_policy.csv");

GetRolesForUser()

GetRolesForUser obtient les rôles qu'un utilisateur a.

Par exemple:

Go

res := e.GetRolesForUser("alice")

Node.js

const res = await e.getRolesForUser('alice')

PHP

$res = $e->getRolesForUser("alice");

Python

roles = e.get_roles_for_user("alice")

.NET

var res = e.GetRolesForUser("alice");

Rust

let roles = e.get_roles_for_user("alice", None); // No domain

Java

List<String> res = e.getRolesForUser("alice");

GetUsersForRole()

GetUsersForRole obtient les utilisateurs qui ont un rôle.

Par exemple:

Go

res := e.GetUsersForRole("data1_admin")

Node.js

const res = await e.getUsersForRole('data1_admin')

PHP

$res = $e->getUsersForRole("data1_admin");

Python

users = e.get_users_for_role("data1_admin")

.NET

var res = e.GetUsersForRole("data1_admin");

Rust

let users = e.get_users_for_role("data1_admin", None); // No domain

Java

List<String> res = e.getUsersForRole("data1_admin");

HasRoleForUser()

HasRoleForUser détermine si un utilisateur a un rôle.

Par exemple:

Go

res := e.HasRoleForUser("alice", "data1_admin")

Node.js

const res = await e.hasRoleForUser('alice', 'data1_admin')

PHP

$res = $e->hasRoleForUser("alice", "data1_admin");

Python

has = e.has_role_for_user("alice", "data1_admin")

.NET

var res = e.HasRoleForUser("alice", "data1_admin");

Rust

let has = e.has_role_for_user("alice", "data1_admin", None); // No domain

Java

boolean res = e.hasRoleForUser("alice", "data1_admin");

AddRoleForUser()

AddRoleForUser ajoute un rôle à un utilisateur. Renvoie false si l'utilisateur a déjà le rôle (aka non affecté).

Par exemple:

Go

e.AddRoleForUser("alice", "data2_admin")

Node.js

await e.addRoleForUser('alice', 'data2_admin')

PHP

$e->addRoleForUser("alice", "data2_admin");

Python

e.add_role_for_user("alice", "data2_admin")

.NET

var added = e.AddRoleForUser("alice", "data2_admin");
or
var added = await e.AddRoleForUserAsync("alice", "data2_admin");

Rust

let added = e.add_role_for_user("alice", "data2_admin", None).await?; // No domain

Java

boolean added = e.addRoleForUser("alice", "data2_admin");

AddRolesForUser()

AddRolesForUser ajoute plusieurs rôles à un utilisateur. Renvoie false si l'utilisateur a déjà l'un de ces rôles (aka non affecté).

Par exemple:

Go

var roles = []string{"data2_admin", "data1_admin"}
e.AddRolesForUser("alice", roles)

Node.js

const roles = ["data1_admin", "data2_admin"];
roles.map((role) => e.addRoleForUser("alice", role));

Rust

let roles = vec!["data1_admin".to_owned(), "data2_admin".to_owned()];
let all_added = e.add_roles_for_user("alice", roles, None).await?; // No domain

DeleteRoleForUser()

DeleteRoleForUser supprime un rôle pour un utilisateur. Renvoie false si l'utilisateur n'a pas le rôle (aka non affecté).

Par exemple:

Go

e.DeleteRoleForUser("alice", "data1_admin")

Node.js

await e.deleteRoleForUser('alice', 'data1_admin')

PHP

$e->deleteRoleForUser("alice", "data1_admin");

Python

e.delete_role_for_user("alice", "data1_admin")

.NET

var deleted = e.DeleteRoleForUser("alice", "data1_admin");
or
var deleted = await e.DeleteRoleForUser("alice", "data1_admin");

Rust

let deleted = e.delete_role_for_user("alice", "data1_admin", None).await?; // No domain

Java

boolean deleted = e.deleteRoleForUser("alice", "data1_admin");

DeleteRolesForUser()

DeleteRolesForUser supprime tous les rôles pour un utilisateur. Renvoie false si l'utilisateur n'a aucun rôle (aka non affecté).

Par exemple:

Go

e.DeleteRolesForUser("alice")

Node.js

await e.deleteRolesForUser('alice')

PHP

$e->deleteRolesForUser("alice");

Python

e.delete_roles_for_user("alice")

.NET

var deletedAtLeastOne = e.DeleteRolesForUser("alice");
or
var deletedAtLeastOne = await e.DeleteRolesForUserAsync("alice");

Rust

let deleted_at_least_one = e.delete_roles_for_user("alice", None).await?; // No domain

Java

boolean deletedAtLeastOne = e.deleteRolesForUser("alice");

DeleteUser()

DeleteUser supprime un utilisateur. Renvoie false si l'utilisateur n'existe pas (aka non affecté).

Par exemple:

Go

e.DeleteUser("alice")

Node.js

await e.deleteUser('alice')

PHP

$e->deleteUser("alice");

Python

e.delete_user("alice")

.NET

var deleted = e.DeleteUser("alice");
or
var deleted = await e.DeleteUserAsync("alice");

Rust

let deleted = e.delete_user("alice").await?;

Java

boolean deleted = e.deleteUser("alice");

DeleteRole()

DeleteRole supprime un rôle.

Par exemple:

Go

e.DeleteRole("data2_admin")

Node.js

await e.deleteRole("data2_admin")

PHP

$e->deleteRole("data2_admin");

Python

e.delete_role("data2_admin")

.NET

var deleted = e.DeleteRole("data2_admin");
or
var deleted = await e.DeleteRoleAsync("data2_admin");

Rust

let deleted = e.delete_role("data2_admin").await?;

Java

e.deleteRole("data2_admin");

DeletePermission()

DeletePermission supprime une permission. Renvoie false si la permission n'existe pas (aka non affectée).

Par exemple:

Go

e.DeletePermission("read")

Node.js

await e.deletePermission('read')

PHP

$e->deletePermission("read");

Python

e.delete_permission("read")

.NET

var deleted = e.DeletePermission("read");
or
var deleted = await e.DeletePermissionAsync("read");

Rust

let deleted = e.delete_permission(vec!["read".to_owned()]).await?;

Java

boolean deleted = e.deletePermission("read");

AddPermissionForUser()

AddPermissionForUser ajoute une permission pour un utilisateur ou un rôle. Renvoie false si l'utilisateur ou le rôle a déjà la permission (aka non affecté).

Par exemple:

Go

e.AddPermissionForUser("bob", "read")

Node.js

await e.addPermissionForUser('bob', 'read')

PHP

$e->addPermissionForUser("bob", "read");

Python

e.add_permission_for_user("bob", "read")

.NET

var added = e.AddPermissionForUser("bob", "read");
or
var added = await e.AddPermissionForUserAsync("bob", "read");

Rust

let added = e.add_permission_for_user("bob", vec!["read".to_owned()]).await?;

Java

boolean added = e.addPermissionForUser("bob", "read");

AddPermissionsForUser()

AddPermissionsForUser ajoute plusieurs permissions pour un utilisateur ou un rôle. Renvoie false si l'utilisateur ou le rôle a déjà l'une des permissions (aka non affecté).

Par exemple:

Go

var permissions = [][]string{{"data1", "read"},{"data2","write"}}
for i := 0; i < len(permissions); i++ {
    e.AddPermissionsForUser("alice", permissions[i])
}

Node.js

const permissions = [
    ["data1", "read"],
    ["data2", "write"],
];

permissions.map((permission) => e.addPermissionForUser("bob", ...permission));

Rust

let permissions = vec![
    vec!["data1".to_owned(), "read".to_owned()],
    vec!["data2".to_owned(), "write".to_owned()],
];

let all_added = e.add_permissions_for_user("bob", permissions).await?;

DeletePermissionForUser()

DeletePermissionForUser supprime une permission pour un utilisateur ou un rôle. Renvoie false si l'utilisateur ou le rôle n'a pas la permission (aka non affecté).

Par exemple:

Go

e.DeletePermissionForUser("bob", "read")

Node.js

await e.deletePermissionForUser("bob", "read")

PHP

$e->deletePermissionForUser("bob", "read");

Python

e.delete_permission_for_user("bob", "read")

.NET

var deleted = e.DeletePermissionForUser("bob", "read");
or
var deleted = await e.DeletePermissionForUserAsync("bob", "read");

Rust

let deleted = e.delete_permission_for_user("bob", vec!["read".to_owned()]).await?;

Java

boolean deleted = e.deletePermissionForUser("bob", "read");

DeletePermissionsForUser()

DeletePermissionsForUser supprime les permissions pour un utilisateur ou un rôle. Renvoie false si l'utilisateur ou le rôle n'a aucune permission (aka non affecté).

Par exemple:

Go

e.DeletePermissionsForUser("bob")

Node.js

await e.deletePermissionsForUser('bob')

PHP

$e->deletePermissionsForUser("bob");

Python

e.delete_permissions_for_user("bob")

.NET

var deletedAtLeastOne = e.DeletePermissionsForUser("bob");
or
var deletedAtLeastOne = await e.DeletePermissionsForUserAsync("bob");

Rust

let deleted_at_least_one = e.delete_permissions_for_user("bob").await?;

Java

boolean deletedAtLeastOne = e.deletePermissionForUser("bob");

GetPermissionsForUser()

GetPermissionsForUser obtient les permissions pour un utilisateur ou un rôle.

Par exemple:

Go

e.GetPermissionsForUser("bob")

Node.js

await e.getPermissionsForUser('bob')

PHP

$e->getPermissionsForUser("bob");

Python

e.get_permissions_for_user("bob")

.NET

var permissions = e.GetPermissionsForUser("bob");

Java

List<List<String>> permissions = e.getPermissionsForUser("bob");

HasPermissionForUser()

HasPermissionForUser détermine si un utilisateur a une permission.

Par exemple:

Go

e.HasPermissionForUser("alice", []string{"read"})

Node.js

await e.hasPermissionForUser('alice', 'read')

PHP

$e->hasPermissionForUser("alice", []string{"read"});

Python

has = e.has_permission_for_user("alice", "read")

.NET

var has = e.HasPermissionForUser("bob", "read");

Rust

let has = e.has_permission_for_user("alice", vec!["data1".to_owned(), "read".to_owned()]);

Java

boolean has = e.hasPermissionForUser("alice", "read");

GetImplicitRolesForUser()

GetImplicitRolesForUser obtient les rôles implicites qu'un utilisateur a. Comparé à GetRolesForUser(), cette fonction récupère les rôles indirects en plus des rôles directs.

Par exemple:

g, alice, role:admin  
g, role:admin, role:user  

GetRolesForUser("alice") peut seulement obtenir: ["role:admin"].\ Mais GetImplicitRolesForUser("alice") obtiendra: ["role:admin", "role:user"].

Par exemple:

Go

e.GetImplicitRolesForUser("alice")

Node.js

await e.getImplicitRolesForUser("alice")

PHP

$e->getImplicitRolesForUser("alice");

Python

e.get_implicit_roles_for_user("alice")

.NET

var implicitRoles = e.GetImplicitRolesForUser("alice");

Rust

e.get_implicit_roles_for_user("alice", None); // No domain

Java

List<String> implicitRoles = e.getImplicitRolesForUser("alice");

GetImplicitUsersForRole()

GetImplicitUsersForRole obtient tous les utilisateurs héritant du rôle. Comparé à GetUsersForRole(), cette fonction récupère les utilisateurs indirects.

Par exemple:

g, alice, role:admin  
g, role:admin, role:user  

GetUsersForRole("role:user") peut seulement obtenir: ["role:admin"].\ Mais GetImplicitUesrsForRole("role:user") obtiendra : ["role:admin", "alice"].

Par exemple :

Go

users := e.GetImplicitUsersForRole("role:user")

Node.js

const users = e.getImplicitUsersForRole("role:user");

Java

List<String> users = e.getImplicitUsersForRole("role:user");

GetImplicitPermissionsForUser()

GetImplicitPermissionsForUser obtient les permissions implicites pour un utilisateur ou un rôle.\ Comparé à GetPermissionsForUser(), cette fonction récupère les permissions pour les rôles hérités.

Par exemple :

p, admin, data1, read  
p, alice, data2, read  
g, alice, admin 

GetPermissionsForUser("alice") ne peut obtenir que : [["alice", "data2", "read"]].\ Mais GetImplicitPermissionsForUser("alice") obtiendra : [["admin", "data1", "read"], ["alice", "data2", "read"]].

Par exemple :

Go

e.GetImplicitPermissionsForUser("alice")

Node.js

await e.getImplicitPermissionsForUser("alice")

PHP

$e->getImplicitPermissionsForUser("alice");

Python

e.get_implicit_permissions_for_user("alice")

.NET

var implicitPermissions = e.GetImplicitPermissionsForUser("alice");

Rust

e.get_implicit_permissions_for_user("alice", None); // No domain

Java

List<List<String>> implicitPermissions = e.getImplicitPermissionsForUser("alice");

GetNamedImplicitPermissionsForUser()

GetNamedImplicitPermissionsForUser obtient les permissions implicites pour un utilisateur ou un rôle par politique nommée. Comparé à GetImplicitPermissionsForUser(), cette fonction vous permet de spécifier le nom de la politique.

Par exemple :

p, admin, data1, read
p2, admin, create
g, alice, admin

GetImplicitPermissionsForUser("alice") n'obtient que : [["admin", "data1", "read"]], dont la politique est par défaut "p"

Mais vous pouvez spécifier la politique comme "p2" pour obtenir : [["admin", "create"]] avec GetNamedImplicitPermissionsForUser("p2","alice")

Par exemple :

Go

e.GetNamedImplicitPermissionsForUser("p2","alice")

Python

e.get_named_implicit_permissions_for_user("p2", "alice")

GetDomainsForUser()

GetDomainsForUser obtient tous les domaines qu'un utilisateur possède.

Par exemple :

p, admin, domain1, data1, read
p, admin, domain2, data2, read
p, admin, domain2, data2, write
g, alice, admin, domain1
g, alice, admin, domain2

GetDomainsForUser("alice") pourrait obtenir ["domain1", "domain2"]

Par exemple :

Go

result, err := e.GetDomainsForUser("alice")

GetImplicitResourcesForUser()

GetImplicitResourcesForUser renvoie toutes les politiques qui devraient être vraies pour l'utilisateur.

Par exemple :

p, alice, data1, read
p, bob, data2, write
p, data2_admin, data2, read
p, data2_admin, data2, write

g, alice, data2_admin

GetImplicitResourcesForUser("alice") renverra [[alice data1 read] [alice data2 read] [alice data2 write]]

Go

resources, err := e.GetImplicitResourcesForUser("alice")

GetImplicitUsersForPermission()

GetImplicitUsersForPermission obtient les utilisateurs implicites pour une permission.

Par exemple :

p, admin, data1, read
p, bob, data1, read
g, alice, admin

GetImplicitUsersForPermission("data1", "read") renverra : ["alice", "bob"].

Note : seuls les utilisateurs seront renvoyés, les rôles (2ème argument dans "g") seront exclus.

Go

users, err := e.GetImplicitUsersForPermission("data1", "read")

GetAllowedObjectConditions()

GetAllowedObjectConditions renvoie un tableau de chaînes de conditions d'objet auxquelles l'utilisateur peut accéder.

Par exemple :

p, alice, r.obj.price < 25, read
p, admin, r.obj.category_id = 2, read
p, bob, r.obj.author = bob, write

g, alice, admin

e.GetAllowedObjectConditions("alice", "read", "r.obj.") renverra ["price < 25", "category_id = 2"], nil

Note :

0. préfixe: Vous pouvez personnaliser le préfixe des conditions de l'objet, et "r.obj." est couramment utilisé comme préfixe. Après avoir supprimé le préfixe, la partie restante est la condition de l'objet. S'il y a une politique obj qui ne répond pas à l'exigence du préfixe, une errors.ERR_OBJ_CONDITION sera renvoyée.

1. Si le tableau 'objectConditions' est vide, renvoie errors.ERR_EMPTY_CONDITION. Cette erreur est renvoyée parce que certains adaptateurs de données ORM renvoient par défaut des données de table complètes lorsqu'ils reçoivent une condition vide, ce qui a tendance à se comporter contrairement aux attentes. (par exemple, GORM) Si vous utilisez un adaptateur qui ne se comporte pas de cette façon, vous pouvez choisir d'ignorer cette erreur.

Go

conditions, err := e.GetAllowedObjectConditions("alice", "read", "r.obj.")

GetImplicitUsersForResource()

GetImplicitUsersForResource renvoie un utilisateur implicite basé sur la ressource.

Par exemple:

p, alice, data1, read
p, bob, data2, write
p, data2_admin, data2, read
p, data2_admin, data2, write
g, alice, data2_admin

GetImplicitUsersForResource("data2") renverra ["bob", "data2", "write"], ["alice", "data2", "read"] ["alice", "data2", "write"]], nil.

GetImplicitUsersForResource("data1") renverra ["alice", "data1", "read"]], nil.

Go

ImplicitUsers, err := e.GetImplicitUsersForResource("data2")

note

Seuls les utilisateurs seront renvoyés, les rôles (2ème argument dans "g") seront exclus.

GetNamedImplicitUsersForResource()

GetNamedImplicitUsersForResource return implicit user based on resource with named policy support. This function handles resource role relationships through named policies (e.g., g2, g3, etc.).

For example:

p, admin_group, admin_data, *
g, admin, admin_group
g2, app, admin_data

GetNamedImplicitUsersForResource("g2", "app") will return users who have access to admin_data through g2 relationship.

Go

ImplicitUsers, err := e.GetNamedImplicitUsersForResource("g2", "app")