RBAC API

RBAC에 대한 더 친숙한 API. 이 API는 Management API의 하위 집합입니다. RBAC 사용자는 이 API를 사용하여 코드를 단순화할 수 있습니다.

참조

전역 변수 e는 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는 사용자가 가진 역할을 가져옵니다.

예를 들어:

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은 역할을 가진 사용자를 가져옵니다.

예를 들어:

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는 사용자가 역할을 가지고 있는지 확인합니다.

예를 들어:

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는 사용자에게 역할을 추가합니다. 사용자가 이미 역할을 가지고 있다면 false를 반환합니다 (즉, 영향을 받지 않음).

예를 들어:

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는 사용자에게 여러 역할을 추가합니다. 사용자가 이미 이러한 역할 중 하나를 가지고 있다면 false를 반환합니다 (즉, 영향을 받지 않음).

예를 들어:

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는 사용자의 역할을 삭제합니다. 사용자가 역할을 가지고 있지 않다면 false를 반환합니다 (즉, 영향을 받지 않음).

예를 들어:

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는 사용자의 모든 역할을 삭제합니다. 사용자가 어떤 역할도 가지고 있지 않다면 false를 반환합니다 (즉, 영향을 받지 않음).

예를 들어:

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는 사용자를 삭제합니다. 사용자가 존재하지 않는 경우 false를 반환합니다 (즉, 영향을 받지 않음).

예를 들어:

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은 역할을 삭제합니다.

예를 들어:

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은 권한을 삭제합니다. 권한이 존재하지 않는 경우 (즉, 영향을 받지 않음) false를 반환합니다.

예를 들어:

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는 사용자 또는 역할에 대한 권한을 추가합니다. 사용자 또는 역할이 이미 권한을 가지고 있는 경우 (즉, 영향을 받지 않음) false를 반환합니다.

예를 들어:

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는 사용자 또는 역할에 대해 여러 권한을 추가합니다. 사용자 또는 역할이 이미 권한 중 하나를 가지고 있는 경우 (즉, 영향을 받지 않음) false를 반환합니다.

예를 들어:

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는 사용자 또는 역할에 대한 권한을 삭제합니다. 사용자 또는 역할이 권한을 가지고 있지 않은 경우 (즉, 영향을 받지 않음) false를 반환합니다.

예를 들어:

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는 사용자 또는 역할에 대한 권한을 삭제합니다. 사용자 또는 역할이 어떤 권한도 가지고 있지 않은 경우 (즉, 영향을 받지 않음) false를 반환합니다.

예를 들어:

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는 사용자 또는 역할에 대한 권한을 가져옵니다.

예를 들어:

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");

GetNamedPermissionsForUser()

GetNamedPermissionsForUser gets permissions for a user or role by named policy.

예를 들어:

p, alice, data1, read
p, bob, data2, write
p2, admin, create
g, alice, admin

GetNamedPermissionsForUser("p", "alice") will return [["alice", "data1", "read"]]. GetNamedPermissionsForUser("p2", "alice") will return [["admin", "create"]].

Go

permissions, err := e.GetNamedPermissionsForUser("p", "alice")

Python

permissions = e.get_named_permissions_for_user("p", "alice")

HasPermissionForUser()

HasPermissionForUser는 사용자가 권한을 가지고 있는지 확인합니다.

예를 들어:

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는 사용자가 가진 암시적 역할을 가져옵니다. GetRolesForUser()와 비교하여, 이 함수는 직접적인 역할 외에 간접적인 역할을 검색합니다.

예를 들어:

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

GetRolesForUser("alice")는 오직: ["role:admin"]만 가져올 수 있습니다.\ 하지만 GetImplicitRolesForUser("alice")는: ["role:admin", "role:user"]를 가져올 것입니다.

예를 들어:

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");

GetNamedImplicitRolesForUser()

GetNamedImplicitRolesForUser gets implicit roles that a user has by named policy.

예를 들어:

g, alice, admin
g, admin, super_admin
g2, alice, user
g2, user, guest

GetNamedImplicitRolesForUser("g", "alice") will return ["admin", "super_admin"]. GetNamedImplicitRolesForUser("g2", "alice") will return ["user", "guest"].

Go

roles, err := e.GetNamedImplicitRolesForUser("g", "alice")

Python

roles = e.get_named_implicit_roles_for_user("g", "alice")

GetImplicitUsersForRole()

GetImplicitUsersForRole은 역할을 상속받는 모든 사용자를 가져옵니다. GetUsersForRole()와 비교하여, 이 함수는 간접적인 사용자를 검색합니다.

For example:

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

GetUsersForRole("role:user")는 오직: ["role:admin"]만 가져올 수 있습니다.\ 하지만 GetImplicitUesrsForRole("role:user")는 다음을 얻을 것입니다: ["role:admin", "alice"].

For example:

Go

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

Node.js

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

Java

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

GetImplicitPermissionsForUser()

GetImplicitPermissionsForUser는 사용자 또는 역할에 대한 암시적 권한을 가져옵니다.\ GetPermissionsForUser()에 비해 이 함수는 상속된 역할에 대한 권한을 검색합니다.

예를 들어:

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

GetPermissionsForUser("alice")는 오직 다음을 얻을 수 있습니다: [["alice", "data2", "read"]].\ 하지만 GetImplicitPermissionsForUser("alice")는 다음을 얻을 것입니다: [["admin", "data1", "read"], ["alice", "data2", "read"]].

예를 들어:

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는 명명된 정책에 의해 사용자 또는 역할에 대한 암시적 권한을 가져옵니다. GetImplicitPermissionsForUser()에 비해 이 함수는 정책 이름을 지정할 수 있게 해줍니다.

예를 들어:

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

GetImplicitPermissionsForUser("alice")는 오직 다음을 얻을 수 있습니다: [["admin", "data1", "read"]], 이는 기본적으로 "p" 정책입니다

하지만 정책을 "p2"로 지정하여 GetNamedImplicitPermissionsForUser("p2","alice")로 다음을 얻을 수 있습니다: [["admin", "create"]].

예를 들어:

Go

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

Python

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

GetDomainsForUser()

GetDomainsForUser는 사용자가 가진 모든 도메인을 가져옵니다.

예를 들어:

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")는 ["domain1", "domain2"]를 얻을 수 있습니다.

예를 들어:

Go

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

GetImplicitResourcesForUser()

GetImplicitResourcesForUser는 사용자에게 참이어야 하는 모든 정책을 반환합니다.

예를 들어:

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

g, alice, data2_admin

GetImplicitResourcesForUser("alice")는 다음을 반환할 것입니다: [[alice data1 read] [alice data2 read] [alice data2 write]]

Go

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

GetImplicitUsersForPermission()

GetImplicitUsersForPermission은 권한에 대한 암시적 사용자를 가져옵니다.

For example:

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

GetImplicitUsersForPermission("data1", "read")는 다음을 반환할 것입니다: ["alice", "bob"].

참고: 오직 사용자만 반환되며, 역할("g"의 2번째 인수)은 제외됩니다.

Go

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

GetImplicitObjectPatternsForUser()

GetImplicitObjectPatternsForUser returns all object patterns (with wildcards) that a user has for a given domain and action.

For example:

p, admin, chronicle/123, location/*, read
p, user, chronicle/456, location/789, read
g, alice, admin
g, bob, user

GetImplicitObjectPatternsForUser("alice", "chronicle/123", "read") will return ["location/*"]. GetImplicitObjectPatternsForUser("bob", "chronicle/456", "read") will return ["location/789"].

Go

patterns, err := e.GetImplicitObjectPatternsForUser("alice", "chronicle/123", "read")

Node.js

const patterns = await e.getImplicitObjectPatternsForUser("alice", "chronicle/123", "read")

PHP

$patterns = $e->getImplicitObjectPatternsForUser("alice", "chronicle/123", "read");

Python

patterns = e.get_implicit_object_patterns_for_user("alice", "chronicle/123", "read")

.NET

var patterns = e.GetImplicitObjectPatternsForUser("alice", "chronicle/123", "read");

Rust

let patterns = e.get_implicit_object_patterns_for_user("alice", "chronicle/123", "read").await?;

Java

List<String> patterns = e.getImplicitObjectPatternsForUser("alice", "chronicle/123", "read");

GetAllowedObjectConditions()

GetAllowedObjectConditions는 사용자가 접근할 수 있는 객체 조건의 문자열 배열을 반환합니다.

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.") 다음을 반환할 것입니다: ["price < 25", "category_id = 2"], nil

참고:

0. prefix: 객체 조건의 접두사를 사용자 정의할 수 있으며, "r.obj."가 일반적으로 접두사로 사용됩니다. 접두사를 제거한 후 남은 부분은 객체의 조건입니다. 접두사 요구사항을 충족하지 않는 obj 정책이 있으면 errors.ERR_OBJ_CONDITION이 반환됩니다.

1. 'objectConditions' 배열이 비어 있으면 errors.ERR_EMPTY_CONDITION을 반환합니다. 이 오류는 일부 데이터 어댑터의 ORM이 비어 있는 조건을 받으면 기본적으로 전체 테이블 데이터를 반환하기 때문에 반환됩니다. 이는 기대와는 반대로 동작하는 경향이 있습니다.(예: GORM) 이와 같이 동작하지 않는 어댑터를 사용하고 있다면 이 오류를 무시할 수 있습니다.

Go

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

GetImplicitUsersForResource()

GetImplicitUsersForResource는 리소스를 기반으로 한 암시적 사용자를 반환합니다.

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")는 ["bob", "data2", "write"], ["alice", "data2", "read"] ["alice", "data2", "write"]], nil을 반환합니다.

GetImplicitUsersForResource("data1")는 ["alice", "data1", "read"]], nil을 반환합니다.

Go

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

노트

사용자만 반환되며, 역할("g"의 2번째 인수)은 제외됩니다.

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