RBAC API

Eine benutzerfreundlichere API für RBAC. Diese API ist eine Teilmenge der Management-API. Die RBAC-Benutzer können diese API verwenden, um den Code zu vereinfachen.

Referenz

globale Variable e ist Enforcer Instanz.

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 erhält die Rollen, die ein Benutzer hat.

Zum Beispiel:

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

laßt Rollen = e.get_roles_for_user("alice", keine); // Keine Domain

Java

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

GetUsersForRole()

GetUsersForRole holt die Benutzer, die eine Rolle haben.

Zum Beispiel:

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

den Benutzern = e.get_users_for_role("data1_admin", keine); // Keine Domain

Java

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

HasRoleForUser()

HasRoleForUser bestimmt, ob ein Benutzer eine Rolle hat.

Zum Beispiel:

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", keine); // Keine Domain

Java

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

AddRoleForUser()

AddRoleForUser fügt eine Rolle für einen Benutzer hinzu. Gibt false zurück, wenn der Benutzer bereits die Rolle hat (aka nicht betroffen).

Zum Beispiel:

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", keine).await?; // Keine Domain

Java

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

AddRolesForUser()

AddRolesForUser fügt mehrere Rollen für einen Benutzer hinzu. Gibt false zurück, wenn der Benutzer bereits eine dieser Rollen hat (aka nicht betroffen).

Zum Beispiel:

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

lasse Rollen = vec!["data1_admin".to_owned(), "data2_admin".to_owned()];
lasse all_added = e.add_roles_for_user("alice", Rollen, None).await?; // Keine Domain

DeleteRoleForUser()

DeleteRoleForUser löscht eine Rolle für einen Benutzer. Gibt false zurück, wenn der Benutzer nicht die Rolle hat (aka nicht betroffen).

Zum Beispiel:

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

delete_role_for_user("alice", "data1_admin", keine).warte?; // Keine Domain

Java

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

DeleteRolesForUser()

DeleteRolesForUser löscht alle Rollen eines Benutzers. Gibt false zurück, wenn der Benutzer keine Rollen hat (aka nicht betroffen).

Zum Beispiel:

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

deleted_at_least_one = e.delete_roles_for_user("alice", keine).warte?; // Keine Domain

Java

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

DeleteUser()

Löscht Benutzer einen Benutzer. Gibt false zurück, wenn der Benutzer nicht existiert (auch nicht betroffen).

Zum Beispiel:

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()

Lösche Rolle löscht eine Rolle.

Zum Beispiel:

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 löscht eine Berechtigung. Gibt false zurück, wenn die Berechtigung nicht vorhanden ist (aka nicht betroffen).

Zum Beispiel:

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 fügt eine Berechtigung für einen Benutzer oder eine Rolle hinzu. Gibt falsch zurück, wenn der Benutzer oder die Rolle bereits die Berechtigung hat (aka nicht betroffen).

Zum Beispiel:

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 fügt mehrere Berechtigungen für einen Benutzer oder eine Rolle hinzu. Gibt falsch zurück, wenn der Benutzer oder die Rolle bereits eine der Berechtigungen hat (aka nicht betroffen).

Zum Beispiel:

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 löscht eine Berechtigung für einen Benutzer oder eine Rolle. Gibt false zurück, wenn der Benutzer oder die Rolle nicht über die Berechtigung verfügt (aka nicht betroffen).

Zum Beispiel:

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 löscht Berechtigungen für einen Benutzer oder eine Rolle. Gibt falsch zurück, wenn der Benutzer oder die Rolle keine Berechtigungen hat (aka nicht betroffen).

Zum Beispiel:

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 erhält Berechtigungen für einen Benutzer oder eine Rolle.

Zum Beispiel:

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 bestimmt, ob ein Benutzer eine Berechtigung hat.

Zum Beispiel:

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 erhält implizite Rollen, die ein Benutzer hat. Verglichen mit GetRolesForUser() ruft diese Funktion neben direkten Rollen indirekte Rollen ab.

Zum Beispiel:
g, alice, role:admin
g, role:admin, role:user

GetRolesForUser("alice") kann nur erhalten: ["role:admin"].
Aber GetImplicitRolesForUser("alice") bekommt: ["role:admin", "role:user"].

Zum Beispiel:

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", kein); // Keine Domain

Java

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

GetImplicitUsersForRole()

GetImplicitUsersForRole holt alle Benutzer, die die Rolle übernehmen. Im Vergleich zu GetUsersForRole() ermittelt diese Funktion indirekte Benutzer.

Zum Beispiel:
g, alice, role:admin
g, role:admin, role:user

GetUsersForRole("role:user") kann nur erhalten: ["role:admin"].
Aber GetImplicitUesrsForRole("role:user") bekommt: ["role:admin", "alice"].

Zum Beispiel:

Go

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

Node.js

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

Java

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

GetImplicitPermissionsForUser()

GetImplicitPermissionsForUser erhält implizite Berechtigungen für einen Benutzer oder eine Rolle.
Verglichen mit GetPermissionsForUser(), diese Funktion holt Berechtigungen für geerbte Rollen.

Beispiel:
p, admin, data1, lesen Sie
p, alice, data2, lesen Sie
g, alice, admin

GetPermissionsForUser("alice") kann nur erhalten: [["alice", "data2", "read"]].
Aber GetImplicitPermissionsForUser("alice") holt: [["admin", "data1", "read"], ["alice", "data2", "read"]].

Zum Beispiel:

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", kein); // Keine Domain

Java

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

GetNamedImplicitPermissionsForUser()

GetNamedImplicitPermissionsForUser erhält implizite Berechtigungen für einen Benutzer oder eine Rolle durch benannte Richtlinie Verglichen mit GetImplicitPermissionsForUser(). Diese Funktion erlaubt es Ihnen, den Richtliniennamen anzugeben.

Beispiel: p, admin, data1, lesen Sie p2, admin, erstellen g, alice, admin

GetImplicitPermissionsForUser("alice") nur erhalten: [["admin", "data1", "read"", dessen Richtlinie "p" ist

Aber Sie können die Richtlinie als "p2" angeben, um sie zu erhalten: [["admin", "erstellen"]] von GetNamedImplicitPermissionsForUser("p2","alice")

Zum Beispiel:

Go

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

Python

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

GetDomainsForUser()

GetDomainsForUser erhält alle Domains, die ein Benutzer hat.

Beispiel: p, admin, domain1, data1, lesen Sie p, admin, domain2, data2, lesen Sie p, admin, domain2, data2, schreiben Sie g, alice, admin, domain1 g, alice, admin, domain2

GetDomainsForUser("alice") könnte ["domain1", "domain2"] erhalten

Zum Beispiel:

Go

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

GetImplicitResourcesForUser()

GetImplicitResourcesForUser gibt alle Richtlinien zurück, die für den Benutzer zutreffen sollten.

Zum Beispiel:

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

g, alice, data2_admin

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

Go

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

GetImplicitUsersForPermission()

GetImplicitUsersForPermission gets implicit users for a permission.

For example:

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

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

Note: only users will be returned, roles (2nd arg in "g") will be excluded.

Go

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

GetAllowedObjectConditions()

GetAllowedObjectConditions returns a string array of object conditions that the user can access.

For example:

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.") will return ["price < 25", "category_id = 2"], nil

Note:

0. prefix: You can customize the prefix of the object conditions, and "r.obj." is commonly used as a prefix. After removing the prefix, the remaining part is the condition of the object. If there is an obj policy that does not meet the prefix requirement, an errors.ERR_OBJ_CONDITION will be returned.

1. If the 'objectConditions' array is empty, return errors.ERR_EMPTY_CONDITION This error is returned because some data adapters' ORM return full table data by default when they receive an empty condition, which tends to behave contrary to expectations.(e.g. GORM) If you are using an adapter that does not behave like this, you can choose to ignore this error.

Go

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

GetImplicitUsersForResource()

GetImplicitUsersForResource return implicit user based on resource.

For example:

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

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

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

Go

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

note

Only users will be returned, roles (2nd arg in "g") will be excluded.