Management API

Примітивний API, який забезпечує повну підтримку управління політикою Casbin.

Filtered API

Майже всі фільтровані api мають однакові параметри (fieldIndex int, fieldValues ...string). fieldIndex - це індекс, з якого починається співставлення, fieldValues позначає значення, які повинен мати результат. Зауважте, що порожній рядок у fieldValues може бути будь-яким словом.

Приклад:

p, alice, book, read
p, bob, book, read
p, bob, book, write
p, alice, pen, get
p, bob, pen ,get

e.GetFilteredPolicy(1, "book") // will return: [[alice book read] [bob book read] [bob book write]]

e.GetFilteredPolicy(1, "book", "read") // will return: [[alice book read] [bob book read]]

e.GetFilteredPolicy(0, "alice", "", "read") // will return: [[alice book read]]

e.GetFilteredPolicy(0, "alice") // will return: [[alice book read] [alice pen get]]

Довідка

Глобальна змінна 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 = Enforce::new("examples/rbac_model.conf", "examples/rbac_policy.csv").await?;

Java

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

Enforce()

Enforce вирішує, чи може "суб'єкт" отримати доступ до "об'єкта" з операцією "дія", зазвичай вхідні параметри: (sub, obj, act).

Наприклад:

Go

ok, err := e.Enforce(request)

Node.js

const ok = await e.enforce(request);

PHP

$ok = $e->enforcer($request);

Python

ok = e.enforcer(request)

Java

boolean ok = e.enforce(request);

EnforceWithMatcher()

EnforceWithMatcher використовує власний матчер для вирішення, чи може "суб'єкт" отримати доступ до "об'єкта" з операцією "дія", зазвичай вхідні параметри: (matcher, sub, obj, act), використовує матчер моделі за замовчуванням, коли матчер є "".

Наприклад:

Go

ok, err := e.EnforceWithMatcher(matcher, request)

PHP

$ok = $e->enforceWithMatcher($matcher, $request);

Python

ok = e.enforce_with_matcher(matcher, request)

Java

boolean ok = e.enforceWithMatcher(matcher, request);

EnforceEx()

EnforceEx пояснює виконання, інформуючи про відповідні правила.

Наприклад:

Go

ok, reason, err := e.EnforceEx(request)

Node.js

const ok = await e.enforceEx(request);

PHP

list($ok, $reason) = $e->enforceEx($request);

Python

ok, reason = e.enforce_ex(request)

EnforceExWithMatcher()

EnforceExWithMatcher використовує власний матчер і пояснює виконання, інформуючи про відповідні правила.

Наприклад:

Go

ok, reason, err := e.EnforceExWithMatcher(matcher, request)

BatchEnforce()

BatchEnforce виконує кожен запит і повертає результат у масиві bool

Наприклад:

Go

boolArray, err := e.BatchEnforce(requests)

Node.js

const boolArray = await e.batchEnforce(requests);

Java

List<Boolean> boolArray = e.batchEnforce(requests);

GetAllSubjects()

GetAllSubjects отримує список суб'єктів, які з'являються в поточній політиці.

Наприклад:

Go

allSubjects := e.GetAllSubjects()

Node.js

const allSubjects = await e.getAllSubjects()

PHP

$allSubjects = $e->getAllSubjects();

Python

all_subjects = e.get_all_subjects()

.NET

var allSubjects = e.GetAllSubjects();

Rust

let all_subjects = e.get_all_subjects();

Java

List<String> allSubjects = e.getAllSubjects();

GetAllNamedSubjects()

GetAllNamedSubjects отримує список суб'єктів, які з'являються в поточній іменованій політиці.

Наприклад:

Go

allNamedSubjects := e.GetAllNamedSubjects("p")

Node.js

const allNamedSubjects = await e.getAllNamedSubjects('p')

PHP

$allNamedSubjects = $e->getAllNamedSubjects("p");

Python

all_named_subjects = e.get_all_named_subjects("p")

.NET

var allNamedSubjects = e.GetAllNamedSubjects("p");

Rust

let all_named_subjects = e.get_all_named_subjects("p");

Java

List<String> allNamedSubjects = e.getAllNamedSubjects("p");

GetAllObjects()

GetAllObjects отримує список об'єктів, які з'являються в поточній політиці.

Наприклад:

Go

allObjects := e.GetAllObjects()

Node.js

const allObjects = await e.getAllObjects()

PHP

$allObjects = $e->getAllObjects();

Python

all_objects = e.get_all_objects()

.NET

var allObjects = e.GetAllObjects();

Rust

let all_objects = e.get_all_objects();

Java

List<String> allObjects = e.getAllObjects();

GetAllNamedObjects()

GetAllNamedObjects отримує список об'єктів, які з'являються в поточній іменованій політиці.

Наприклад:

Go

allNamedObjects := e.GetAllNamedObjects("p")

Node.js

const allNamedObjects = await e.getAllNamedObjects('p')

PHP

$allNamedObjects = $e->getAllNamedObjects("p");

Python

all_named_objects = e.get_all_named_objects("p")

.NET

var allNamedObjects = e.GetAllNamedObjects("p");

Rust

let all_named_objects = e.get_all_named_objects("p");

Java

List<String> allNamedObjects = e.getAllNamedObjects("p");

GetAllActions()

GetAllActions отримує список дій, які з'являються в поточній політиці.

Наприклад:

Go

allActions := e.GetAllActions()

Node.js

const allActions = await e.getAllActions()

PHP

$allActions = $e->getAllActions();

Python

all_actions = e.get_all_actions()

.NET

var allActions = e.GetAllActions();

Rust

let all_actions = e.get_all_actions();

Java

List<String> allActions = e.getAllActions();

GetAllNamedActions()

GetAllNamedActions отримує список дій, які з'являються в поточній іменованій політиці.

Наприклад:

Go

allNamedActions := e.GetAllNamedActions("p")

Node.js

const allNamedActions = await e.getAllNamedActions('p')

PHP

$allNamedActions = $e->getAllNamedActions("p");

Python

all_named_actions = e.get_all_named_actions("p")

.NET

var allNamedActions = e.GetAllNamedActions("p");

Rust

let all_named_actions = e.get_all_named_actions("p");

Java

List<String> allNamedActions = e.getAllNamedActions("p");

GetAllRoles()

GetAllRoles отримує список ролей, які з'являються в поточній політиці.

Наприклад:

Go

allRoles = e.GetAllRoles()

Node.js

const allRoles = await e.getAllRoles()

PHP

$allRoles = $e->getAllRoles();

Python

all_roles = e.get_all_roles()

.NET

var allRoles = e.GetAllRoles();

Rust

let all_roles = e.get_all_roles();

Java

List<String> allRoles = e.getAllRoles();

GetAllNamedRoles()

GetAllNamedRoles отримує список ролей, які з'являються в поточній іменованій політиці.

Наприклад:

Go

allNamedRoles := e.GetAllNamedRoles("g")

Node.js

const allNamedRoles = await e.getAllNamedRoles('g')

PHP

$allNamedRoles = $e->getAllNamedRoles('g');

Python

all_named_roles = e.get_all_named_roles("g")

.NET

var allNamedRoles = e.GetAllNamedRoles("g");

Rust

let all_named_roles = e.get_all_named_roles("g");

Java

List<String> allNamedRoles = e.getAllNamedRoles("g");

GetPolicy()

GetPolicy отримує всі правила авторизації в політиці.

Наприклад:

Go

policy = e.GetPolicy()

Node.js

const policy = await e.getPolicy()

PHP

$policy = $e->getPolicy();

Python

policy = e.get_policy()

.NET

var policy = e.GetPolicy();

Rust

let policy = e.get_policy();

Java

List<List<String>> policy = e.getPolicy();

GetFilteredPolicy()

GetFilteredPolicy отримує всі правила авторизації в політиці, можна вказати фільтри полів.

Наприклад:

Go

filteredPolicy := e.GetFilteredPolicy(0, "alice")

Node.js

const filteredPolicy = await e.getFilteredPolicy(0, 'alice')

PHP

$filteredPolicy = $e->getFilteredPolicy(0, "alice");

Python

filtered_policy = e.get_filtered_policy(0, "alice")

.NET

var filteredPolicy = e.GetFilteredPolicy(0, "alice");

Rust

let filtered_policy = e.get_filtered_policy(0, vec!["alice".to_owned()]);

Java

List<List<String>> filteredPolicy = e.getFilteredPolicy(0, "alice");

GetNamedPolicy()

GetNamedPolicy отримує всі правила авторизації в іменованій політиці.

Наприклад:

Go

namedPolicy := e.GetNamedPolicy("p")

Node.js

const namedPolicy = await e.getNamedPolicy('p')

PHP

$namedPolicy = $e->getNamedPolicy("p");

Python

named_policy = e.get_named_policy("p")

.NET

var namedPolicy = e.GetNamedPolicy("p");

Rust

let named_policy = e.get_named_policy("p");

Java

List<List<String>> namedPolicy = e.getNamedPolicy("p");

GetFilteredNamedPolicy()

GetFilteredNamedPolicy отримує всі правила авторизації в іменованій політиці, можна вказати фільтри полів.

Наприклад:

Go

filteredNamedPolicy = e.GetFilteredNamedPolicy("p", 0, "bob")

Node.js

const filteredNamedPolicy = await e.getFilteredNamedPolicy('p', 0, 'bob')

PHP

$filteredNamedPolicy = $e->getFilteredNamedPolicy("p", 0, "bob");

Python

filtered_named_policy = e.get_filtered_named_policy("p", 0, "alice")

.NET

var filteredNamedPolicy = e.GetFilteredNamedPolicy("p", 0, "alice");

Rust

let filtered_named_policy = e.get_filtered_named_policy("p", 0, vec!["bob".to_owned()]);

Java

List<List<String>> filteredNamedPolicy = e.getFilteredNamedPolicy("p", 0, "bob");

GetGroupingPolicy()

GetGroupingPolicy отримує всі правила спадкування ролей в політиці.

Наприклад:

Go

groupingPolicy := e.GetGroupingPolicy()

Node.js

const groupingPolicy = await e.getGroupingPolicy()

PHP

$groupingPolicy = $e->getGroupingPolicy();

Python

grouping_policy = e.get_grouping_policy()

.NET

var groupingPolicy = e.GetGroupingPolicy();

Rust

let grouping_policy = e.get_grouping_policy();

Java

List<List<String>> groupingPolicy = e.getGroupingPolicy();

GetFilteredGroupingPolicy()

GetFilteredGroupingPolicy отримує всі правила спадкування ролей в політиці, можна вказати фільтри полів.

Наприклад:

Go

filteredGroupingPolicy := e.GetFilteredGroupingPolicy(0, "alice")

Node.js

const filteredGroupingPolicy = await e.getFilteredGroupingPolicy(0, 'alice')

PHP

$filteredGroupingPolicy = $e->getFilteredGroupingPolicy(0, "alice");

Python

filtered_grouping_policy = e.get_filtered_grouping_policy(0, "alice")

.NET

var filteredGroupingPolicy = e.GetFilteredGroupingPolicy(0, "alice");

Rust

let filtered_grouping_policy = e.get_filtered_grouping_policy(0, vec!["alice".to_owned()]);

Java

List<List<String>> filteredGroupingPolicy = e.getFilteredGroupingPolicy(0, "alice");

GetNamedGroupingPolicy()

GetNamedGroupingPolicy отримує всі правила спадкування ролей в іменованій політиці.

Наприклад:

Go

namedGroupingPolicy := e.GetNamedGroupingPolicy("g")

Node.js

const namedGroupingPolicy = await e.getNamedGroupingPolicy('g')

PHP

$namedGroupingPolicy = $e->getNamedGroupingPolicy("g");

Python

named_grouping_policy = e.get_named_grouping_policy("g")

.NET

var namedGroupingPolicy = e.GetNamedGroupingPolicy("g");

Rust

let named_grouping_policy = e.get_named_grouping_policy("g");

Java

List<List<String>> namedGroupingPolicy = e.getNamedGroupingPolicy("g");

GetFilteredNamedGroupingPolicy()

GetFilteredNamedGroupingPolicy отримує всі правила спадкування ролей в іменованій політиці.

Наприклад:

Go

namedGroupingPolicy := e.GetFilteredNamedGroupingPolicy("g", 0, "alice")

Node.js

const namedGroupingPolicy = await e.getFilteredNamedGroupingPolicy('g', 0, 'alice')

PHP

$namedGroupingPolicy = $e->getFilteredNamedGroupingPolicy("g", 0, "alice");

Python

named_grouping_policy = e.get_filtered_named_grouping_policy("g", 0, "alice")

.NET

var namedGroupingPolicy = e.GetFilteredNamedGroupingPolicy("g", 0, "alice");

Rust

let named_grouping_policy = e.get_filtered_named_groupingPolicy("g", 0, vec!["alice".to_owned()]);

Java

List<List<String>> filteredNamedGroupingPolicy = e.getFilteredNamedGroupingPolicy("g", 0, "alice");

HasPolicy()

HasPolicy визначає, чи існує правило авторизації.

Наприклад:

Go

hasPolicy := e.HasPolicy("data2_admin", "data2", "read")

Node.js

const hasPolicy = await e.hasPolicy('data2_admin', 'data2', 'read')

PHP

$hasPolicy = $e->hasPolicy('data2_admin', 'data2', 'read');

Python

has_policy = e.has_policy("data2_admin", "data2", "read")

.NET

var hasPolicy = e.HasPolicy("data2_admin", "data2", "read");

Rust

let has_policy = e.has_policy(vec!["data2_admin".to_owned(), "data2".to_owned(), "read".to_owned()]);

Java

boolean hasPolicy = e.hasPolicy("data2_admin", "data2", "read");

HasNamedPolicy()

HasNamedPolicy визначає, чи існує іменоване правило авторизації.

Наприклад:

Go

hasNamedPolicy := e.HasNamedPolicy("p", "data2_admin", "data2", "read")

Node.js

const hasNamedPolicy = await e.hasNamedPolicy('p', 'data2_admin', 'data2', 'read')

PHP

$hasNamedPolicy = $e->hasNamedPolicy("p", "data2_admin", "data2", "read");

Python

has_named_policy = e.has_named_policy("p", "data2_admin", "data2", "read")

.NET

var hasNamedPolicy = e.HasNamedPolicy("p", "data2_admin", "data2", "read");

Rust

let has_named_policy = e.has_named_policy("p", vec!["data2_admin".to_owned(), "data2".to_owned(), "read".to_owned()]);

Java

boolean hasNamedPolicy = e.hasNamedPolicy("p", "data2_admin", "data2", "read");

AddPolicy()

AddPolicy додає правило авторизації до поточної політики. Якщо правило вже існує, функція повертає false і правило не буде додано. В іншому випадку функція повертає true, додаючи нове правило.

Наприклад:

Go

added := e.AddPolicy('eve', 'data3', 'read')

Node.js

const p = ['eve', 'data3', 'read']
const added = await e.addPolicy(...p)

PHP

$added = $e->addPolicy('eve', 'data3', 'read');

Python

added = e.add_policy("eve", "data3", "read")

.NET

var added = e.AddPolicy("eve", "data3", "read");
or
var added = await e.AddPolicyAsync("eve", "data3", "read");

Rust

let added = e.add_policy(vec!["eve".to_owned(), "data3".to_owned(), "read".to_owned()]);

Java

boolean added = e.addPolicy("eve", "data3", "read");

AddPolicies()

AddPolicies додає правила авторизації до поточної політики. Операція є атомарною за своєю природою. Отже, якщо правила авторизації складаються з правил, які не узгоджуються з поточною політикою, функція повертає false і жодне правило політики не додається до поточної політики. Якщо всі правила авторизації узгоджуються з правилами політики, функція повертає true і кожне правило політики додається до поточної політики.

Наприклад:

Go

rules := [][] string {
    []string {"jack", "data4", "read"},
    []string {"katy", "data4", "write"},
    []string {"leyo", "data4", "read"},
    []string {"ham", "data4", "write"},
}

areRulesAdded := e.AddPolicies(rules)

Node.js

const rules = [
    ['jack', 'data4', 'read'],
    ['katy', 'data4', 'write'],
    ['leyo', 'data4', 'read'],
    ['ham', 'data4', 'write']
];

const areRulesAdded = await e.addPolicies(rules);

Python

rules = [
    ["jack", "data4", "read"],
    ["katy", "data4", "write"],
    ["leyo", "data4", "read"],
    ["ham", "data4", "write"]
]
are_rules_added = e.add_policies(rules)

Rust

let rules = vec![
    vec!["jack".to_owned(), "data4".to_owned(), "read".to_owned()],
    vec!["katy".to_owned(), "data4".to_owned(), "write".to_owned()],
    vec!["leyo".to_owned(), "data4".to_owned(), "read".to_owned()],
    vec!["ham".to_owned(), "data4".to_owned(), "write".to_owned()],
];

let are_rules_added = e.add_policies(rules).await?

Java

String[][] rules = {
    {"jack", "data4", "read"},
    {"katy", "data4", "write"},
    {"leyo", "data4", "read"},
    {"ham", "data4", "write"},
};

boolean areRulesAdded = e.addPolicies(rules);

AddPoliciesEx()

AddPoliciesEx додає правила авторизації до поточної політики. Якщо правило вже існує, правило не буде додано. Але на відміну від AddPolicies, інші неіснуючі правила додаються замість того, щоб повертати false безпосередньо

Наприклад:

Go

ok, err := e.AddPoliciesEx([][]string{{"user1", "data1", "read"}, {"user2", "data2", "read"}})

AddNamedPolicy()

AddNamedPolicy додає правило авторизації до поточної іменованої політики. Якщо правило вже існує, функція повертає false і правило не буде додано. В іншому випадку функція повертає true, додаючи нове правило.

Наприклад:

Go

added := e.AddNamedPolicy("p", "eve", "data3", "read")

Node.js

const p = ['eve', 'data3', 'read']
const added = await e.addNamedPolicy('p', ...p)

PHP

$added = $e->addNamedPolicy("p", "eve", "data3", "read");

Python

added = e.add_named_policy("p", "eve", "data3", "read")

.NET

var added = e.AddNamedPolicy("p", "eve", "data3", "read");
or
var added = await e.AddNamedPolicyAsync("p", "eve", "data3", "read");

Rust

let added = e.add_named_policy("p", vec!["eve".to_owned(), "data3".to_owned(), "read".to_owned()]).await?;

Java

boolean added = e.addNamedPolicy("p", "eve", "data3", "read");

AddNamedPolicies()

AddNamedPolicies додає правила авторизації до поточної іменованої політики. Операція є атомарною за своєю природою. Отже, якщо правила авторизації складаються з правил, які не узгоджуються з поточною політикою, функція повертає false і жодне правило політики не додається до поточної політики. Якщо всі правила авторизації узгоджуються з правилами політики, функція повертає true і кожне правило політики додається до поточної політики.

Наприклад:

Go

rules := [][] string {
    []string {"jack", "data4", "read"},
    []string {"katy", "data4", "write"},
    []string {"leyo", "data4", "read"},
    []string {"ham", "data4", "write"},
}

areRulesAdded := e.AddNamedPolicies("p", rules)

Node.js

const rules = [
    ['jack', 'data4', 'read'],
    ['katy', 'data4', 'write'],
    ['leyo', 'data4', 'read'],
    ['ham', 'data4', 'write']
];

const areRulesAdded = await e.addNamedPolicies('p', rules);

Python

rules = [
    ["jack", "data4", "read"],
    ["katy", "data4", "write"],
    ["leyo", "data4", "read"],
    ["ham", "data4", "write"]
]
are_rules_added = e.add_named_policies("p", rules)

Rust

let rules = vec![
    vec!["jack".to_owned(), "data4".to_owned(), "read".to_owned()],
    vec!["katy".to_owned(), "data4".to_owned(), "write".to_owned()],
    vec!["leyo".to_owned(), "data4".to_owned(), "read".to_owned()],
    vec!["ham".to_owned(), "data4".to_owned(), "write".to_owned()],
];

let are_rules_added := e.add_named_policies("p", rules).await?;

Java

List<List<String>> rules = Arrays.asList(
    Arrays.asList("jack", "data4", "read"),
    Arrays.asList("katy", "data4", "write"),
    Arrays.asList("leyo", "data4", "read"),
    Arrays.asList("ham", "data4", "write")
);
boolean areRulesAdded = e.addNamedPolicies("p", rules);

AddNamedPoliciesEx()

AddNamedPoliciesEx додає правила авторизації до поточної іменованої політики. Якщо правило вже існує, правило не буде додано. Але на відміну від AddNamedPolicies, інші неіснуючі правила додаються замість того, щоб повертати false безпосередньо

Наприклад:

Go

ok, err := e.AddNamedPoliciesEx("p", [][]string{{"user1", "data1", "read"}, {"user2", "data2", "read"}})

SelfAddPoliciesEx()

SelfAddPoliciesEx додає правила авторизації до поточної іменованої політики з вимкненим autoNotifyWatcher. Якщо правило вже існує, правило не буде додано. Але на відміну від SelfAddPolicies, інші неіснуючі правила додаються замість того, щоб повертати false безпосередньо

Наприклад:

Go

ok, err := e.SelfAddPoliciesEx("p", "p", [][]string{{"user1", "data1", "read"}, {"user2", "data2", "read"}})

RemovePolicy()

RemovePolicy видаляє правило авторизації з поточної політики.

Наприклад:

Go

removed := e.RemovePolicy("alice", "data1", "read")

Node.js

const p = ['alice', 'data1', 'read']
const removed = await e.removePolicy(...p)

PHP

$removed = $e->removePolicy("alice", "data1", "read");

Python

removed = e.remove_policy("alice", "data1", "read")

.NET

var removed = e.RemovePolicy("alice", "data1", "read");
or
var removed = await e.RemovePolicyAsync("alice", "data1", "read");

Rust

let removed = e.remove_policy(vec!["alice".to_owned(), "data1".to_owned(), "read".to_owned()]).await?;

Java

boolean removed = e.removePolicy("alice", "data1", "read");

RemovePolicies()

RemovePolicies видаляє правила авторизації з поточної політики. Операція є атомарною за своєю природою. Отже, якщо правила авторизації складаються з правил, які не узгоджуються з поточною політикою, функція повертає false і жодне правило політики не видаляється з поточної політики. Якщо всі правила авторизації узгоджуються з правилами політики, функція повертає true і кожне правило політики видаляється з поточної політики.

Наприклад:

Go

rules := [][] string {
    []string {"jack", "data4", "read"},
    []string {"katy", "data4", "write"},
    []string {"leyo", "data4", "read"},
    []string {"ham", "data4", "write"},
}

areRulesRemoved := e.RemovePolicies(rules)

Node.js

const rules = [
    ['jack', 'data4', 'read'],
    ['katy', 'data4', 'write'],
    ['leyo', 'data4', 'read'],
    ['ham', 'data4', 'write']
];

const areRulesRemoved = await e.removePolicies(rules);

Python

rules = [
    ["jack", "data4", "read"],
    ["katy", "data4", "write"],
    ["leyo", "data4", "read"],
    ["ham", "data4", "write"]
]
are_rules_removed = e.remove_policies(rules)

Rust

let rules = vec![
    vec!["jack".to_owned(), "data4".to_owned(), "read".to_owned()],
    vec!["katy".to_owned(), "data4".to_owned(), "write".to_owned()],
    vec!["leyo".to_owned(), "data4".to_owned(), "read".to_owned()],
    vec!["ham".to_owned(), "data4".to_owned(), "write".to_owned()],
];

let are_rules_removed = e.remove_policies(rules).await?;

Java

String[][] rules = {
    {"jack", "data4", "read"},
    {"katy", "data4", "write"},
    {"leyo", "data4", "read"},
    {"ham", "data4", "write"},
};
boolean areRulesRemoved = e.removePolicies(rules);

RemoveFilteredPolicy()

RemoveFilteredPolicy видаляє правило авторизації з поточної політики, можна вказати фільтри полів. RemovePolicy видаляє правило авторизації з поточної політики.

Наприклад:

Go

removed := e.RemoveFilteredPolicy(0, "alice", "data1", "read")

Node.js

const p = ['alice', 'data1', 'read']
const removed = await e.removeFilteredPolicy(0, ...p)

PHP

$removed = $e->removeFilteredPolicy(0, "alice", "data1", "read");

Python

removed = e.remove_filtered_policy(0, "alice", "data1", "read")

.NET

var removed = e.RemoveFilteredPolicy("alice", "data1", "read");
or
var removed = await e.RemoveFilteredPolicyAsync("alice", "data1", "read");

Rust

let removed = e.remove_filtered_policy(0, vec!["alice".to_owned(), "data1".to_owned(), "read".to_owned()]).await?;

Java

boolean removed = e.removeFilteredPolicy(0, "alice", "data1", "read");

RemoveNamedPolicy()

RemoveNamedPolicy видаляє правило авторизації з поточної іменованої політики.

Наприклад:

Go

removed := e.RemoveNamedPolicy("p", "alice", "data1", "read")

Node.js

const p = ['alice', 'data1', 'read']
const removed = await e.removeNamedPolicy('p', ...p)

PHP

$removed = $e->removeNamedPolicy("p", "alice", "data1", "read");

Python

removed = e.remove_named_policy("p", "alice", "data1", "read")

.NET

var removed = e.RemoveNamedPolicy("p", "alice", "data1", "read");
or
var removed = await e.RemoveNamedPolicyAsync("p", "alice", "data1", "read");

Rust

let removed = e.remove_named_policy("p", vec!["alice".to_owned(), "data1".to_owned(), "read".to_owned()]).await?;

Java

boolean removed = e.removeNamedPolicy("p", "alice", "data1", "read");

RemoveNamedPolicies()

RemoveNamedPolicies видаляє правила авторизації з поточної іменованої політики. Операція є атомарною за своєю природою. Отже, якщо правила авторизації складаються з правил, які не узгоджуються з поточною політикою, функція повертає false і жодне правило політики не видаляється з поточної політики. Якщо всі правила авторизації відповідають правилам політики, функція повертає true, і кожне правило політики видаляється з поточної політики.

Наприклад:

Go

rules := [][] string {
    []string {"jack", "data4", "read"},
    []string {"katy", "data4", "write"},
    []string {"leyo", "data4", "read"},
    []string {"ham", "data4", "write"},
}

areRulesRemoved := e.RemoveNamedPolicies("p", rules)

Node.js

const rules = [
    ['jack', 'data4', 'read'],
    ['katy', 'data4', 'write'],
    ['leyo', 'data4', 'read'],
    ['ham', 'data4', 'write']
];

const areRulesRemoved = await e.removeNamedPolicies('p', rules);

Python

rules = [
    ["jack", "data4", "read"],
    ["katy", "data4", "write"],
    ["leyo", "data4", "read"],
    ["ham", "data4", "write"]
]
are_rules_removed = e.remove_named_policies("p", rules)

Rust

let rules = vec![
    vec!["jack".to_owned(), "data4".to_owned(), "read".to_owned()],
    vec!["katy".to_owned(), "data4".to_owned(), "write".to_owned()],
    vec!["leyo".to_owned(), "data4".to_owned(), "read".to_owned()],
    vec!["ham".to_owned(), "data4".to_owned(), "write".to_owned()],
];

let areRulesRemoved = e.remove_named_policies("p", rules).await?;

Java

List<List<String>> rules = Arrays.asList(
    Arrays.asList("jack", "data4", "read"),
    Arrays.asList("katy", "data4", "write"),
    Arrays.asList("leyo", "data4", "read"),
    Arrays.asList("ham", "data4", "write")
);
boolean areRulesRemoved = e.removeNamedPolicies("p", rules);

RemoveFilteredNamedPolicy()

RemoveFilteredNamedPolicy видаляє правило авторизації з поточної іменованої політики, можна вказати фільтри полів.

Наприклад:

Go

removed := e.RemoveFilteredNamedPolicy("p", 0, "alice", "data1", "read")

Node.js

const p = ['alice', 'data1', 'read']
const removed = await e.removeFilteredNamedPolicy('p', 0, ...p)

PHP

$removed = $e->removeFilteredNamedPolicy("p", 0, "alice", "data1", "read");

Python

removed = e.remove_filtered_named_policy("p", 0, "alice", "data1", "read")

.NET

var removed = e.RemoveFilteredNamedPolicy("p", 0, "alice", "data1", "read");
or
var removed = e.RemoveFilteredNamedPolicyAync("p", 0, "alice", "data1", "read");

Rust

let removed = e.remove_filtered_named_policy("p", 0, vec!["alice".to_owned(), "data1".to_owned(), "read".to_owned()]).await?;

Java

boolean removed = e.removeFilteredNamedPolicy("p", 0, "alice", "data1", "read");

HasGroupingPolicy()

HasGroupingPolicy визначає, чи існує правило спадкування ролей.

Наприклад:

Go

has := e.HasGroupingPolicy("alice", "data2_admin")

Node.js

const has = await e.hasGroupingPolicy('alice', 'data2_admin')

PHP

$has = $e->hasGroupingPolicy("alice", "data2_admin");

Python

has = e.has_grouping_policy("alice", "data2_admin")

.NET

var has = e.HasGroupingPolicy("alice", "data2_admin");

Rust

let has = e.has_grouping_policy(vec!["alice".to_owned(), "data2_admin".to_owned()]);

Java

boolean has = e.hasGroupingPolicy("alice", "data2_admin");

HasNamedGroupingPolicy()

HasNamedGroupingPolicy визначає, чи існує іменоване правило спадкування ролей.

Наприклад:

Go

has := e.HasNamedGroupingPolicy("g", "alice", "data2_admin")

Node.js

const has = await e.hasNamedGroupingPolicy('g', 'alice', 'data2_admin')

PHP

$has = $e->hasNamedGroupingPolicy("g", "alice", "data2_admin");

Python

has = e.has_named_grouping_policy("g", "alice", "data2_admin")

.NET

var has = e.HasNamedGroupingPolicy("g", "alice", "data2_admin");

Rust

let has = e.has_named_grouping_policy("g", vec!["alice".to_owned(), "data2_admin".to_owned()]);

Java

boolean has = e.hasNamedGroupingPolicy("g", "alice", "data2_admin");

AddGroupingPolicy()

AddGroupingPolicy додає правило спадкування ролей до поточної політики. Якщо правило вже існує, функція повертає false, і правило не буде додано. В іншому випадку функція повертає true, додаючи нове правило.

Наприклад:

Go

added := e.AddGroupingPolicy("group1", "data2_admin")

Node.js

const added = await e.addGroupingPolicy('group1', 'data2_admin')

PHP

$added = $e->addGroupingPolicy("group1", "data2_admin");

Python

added = e.add_grouping_policy("group1", "data2_admin")

.NET

var added = e.AddGroupingPolicy("group1", "data2_admin");
or
var added = await e.AddGroupingPolicyAsync("group1", "data2_admin");

Rust

let added = e.add_grouping_policy(vec!["group1".to_owned(), "data2_admin".to_owned()]).await?;

Java

boolean added = e.addGroupingPolicy("group1", "data2_admin");

AddGroupingPolicies()

AddGroupingPolicies додає правила спадкування ролей до поточної політики. Операція є атомарною за своєю природою. Отже, якщо правила авторизації складаються з правил, які не відповідають поточній політиці, функція повертає false, і жодне правило політики не додається до поточної політики. Якщо всі правила авторизації відповідають правилам політики, функція повертає true, і кожне правило політики додається до поточної політики.

Наприклад:

Go

rules := [][] string {
    []string {"ham", "data4_admin"},
    []string {"jack", "data5_admin"},
}

areRulesAdded := e.AddGroupingPolicies(rules)

Node.js

const groupingRules = [
    ['ham', 'data4_admin'],
    ['jack', 'data5_admin']
  ];

const areRulesAdded = await e.addGroupingPolicies(groupingRules);

Python

rules = [
    ["ham", "data4_admin"],
    ["jack", "data5_admin"]
]

are_rules_added = e.add_grouping_policies(rules)

Rust

let rules = vec![
    vec!["ham".to_owned(), "data4_admin".to_owned()],
    vec!["jack".to_owned(), "data5_admin".to_owned()],
];

let areRulesAdded = e.add_grouping_policies(rules).await?;

Java

String[][] groupingRules = {
    {"ham", "data4_admin"},
    {"jack", "data5_admin"}
};
boolean areRulesAdded = e.addGroupingPolicies(groupingRules);

AddGroupingPoliciesEx()

AddGroupingPoliciesEx додає правила спадкування ролей до поточної політики. Якщо правило вже існує, правило не буде додано. Але на відміну від AddGroupingPolicies, інші неіснуючі правила додаються замість того, щоб повертати false безпосередньо

Наприклад:

Go

ok, err := e.AddGroupingPoliciesEx([][]string{{"user1", "member"}, {"user2", "member"}})

AddNamedGroupingPolicy()

AddNamedGroupingPolicy додає іменоване правило спадкування ролей до поточної політики. Якщо правило вже існує, функція повертає false, і правило не буде додано. В іншому випадку функція повертає true, додаючи нове правило.

Наприклад:

Go

added := e.AddNamedGroupingPolicy("g", "group1", "data2_admin")

Node.js

const added = await e.addNamedGroupingPolicy('g', 'group1', 'data2_admin')

PHP

$added = $e->addNamedGroupingPolicy("g", "group1", "data2_admin");

Python

added = e.add_named_grouping_policy("g", "group1", "data2_admin")

.NET

var added = e.AddNamedGroupingPolicy("g", "group1", "data2_admin");
or
var added = await e.AddNamedGroupingPolicyAsync("g", "group1", "data2_admin");

Rust

let added = e.add_named_grouping_policy("g", vec!["group1".to_owned(), "data2_admin".to_owned()]).await?;

Java

boolean added = e.addNamedGroupingPolicy("g", "group1", "data2_admin");

AddNamedGroupingPolicies()

AddNamedGroupingPolicies додає іменовані правила спадкування ролей до поточної політики. Операція є атомарною за своєю природою. Отже, якщо правила авторизації складаються з правил, які не відповідають поточній політиці, функція повертає false, і жодне правило політики не додається до поточної політики. Якщо всі правила авторизації відповідають правилам політики, функція повертає true, і кожне правило політики додається до поточної політики.

Наприклад:

Go

rules := [][] string {
    []string {"ham", "data4_admin"},
    []string {"jack", "data5_admin"},
}

areRulesAdded := e.AddNamedGroupingPolicies("g", rules)

Node.js

const groupingRules = [
    ['ham', 'data4_admin'],
    ['jack', 'data5_admin']
  ];

const areRulesAdded = await e.addNamedGroupingPolicies('g', groupingRules);

Python

rules = [
    ["ham", "data4_admin"],
    ["jack", "data5_admin"]
]

are_rules_added = e.add_named_grouping_policies("g", rules)

Rust

let rules = vec![
    vec!["ham".to_owned(), "data4_admin".to_owned()],
    vec!["jack".to_owned(), "data5_admin".to_owned()],
];

let are_rules_added = e.add_named_grouping_policies("g", rules).await?;

Java

String[][] groupingRules = {
    {"ham", "data4_admin"},
    {"jack", "data5_admin"}
};
boolean areRulesAdded = e.addNamedGroupingPolicies("g", groupingRules);

AddNamedGroupingPoliciesEx()

AddNamedGroupingPoliciesEx додає іменовані правила спадкування ролей до поточної політики. Якщо правило вже існує, правило не буде додано. Але на відміну від AddNamedGroupingPolicies, інші неіснуючі правила додаються замість того, щоб повертати false безпосередньо

Наприклад:

Go

ok, err := e.AddNamedGroupingPoliciesEx("g", [][]string{{"user1", "member"}, {"user2", "member"}})

RemoveGroupingPolicy()

RemoveGroupingPolicy видаляє правило спадкування ролей з поточної політики.

Наприклад:

Go

removed := e.RemoveGroupingPolicy("alice", "data2_admin")

Node.js

const removed = await e.removeGroupingPolicy('alice', 'data2_admin')

PHP

$removed = $e->removeGroupingPolicy("alice", "data2_admin");

Python

removed = e.remove_grouping_policy("alice", "data2_admin")

.NET

var removed = e.RemoveGroupingPolicy("alice", "data2_admin");
or
var removed = await e.RemoveGroupingPolicyAsync("alice", "data2_admin");

Rust

let removed = e.remove_grouping_policy(vec!["alice".to_owned(), "data2_admin".to_owned()]).await?;

Java

boolean removed = e.removeGroupingPolicy("alice", "data2_admin");

RemoveGroupingPolicies()

RemoveGroupingPolicies видаляє правила спадкування ролей з поточної політики. Операція є атомарною за своєю природою. Отже, якщо правила авторизації складаються з правил, які не відповідають поточній політиці, функція повертає false, і жодне правило політики не видаляється з поточної політики. Якщо всі правила авторизації відповідають правилам політики, функція повертає true, і кожне правило політики видаляється з поточної політики.

Наприклад:

Go

rules := [][] string {
                []string {"ham", "data4_admin"},
                []string {"jack", "data5_admin"},
        }

areRulesRemoved := e.RemoveGroupingPolicies(rules)

Node.js

const groupingRules = [
    ['ham', 'data4_admin'],
    ['jack', 'data5_admin']
  ];

const areRulesRemoved = await e.removeGroupingPolicies(groupingRules);

Rust

let rules = vec![
    vec!["ham".to_owned(), "data4_admin".to_owned()],
    vec!["jack".to_owned(), "data5_admin".to_owned()],
];

let are_rules_removed = e.remove_grouping_policies(rules).await?;

Python

rules = [
    ["ham", "data4_admin"],
    ["jack", "data5_admin"]
]

are_rules_removed = e.remove_grouping_policies(rules)

Java

String[][] groupingRules = {
    {"ham", "data4_admin"},
    {"jack", "data5_admin"}
};
boolean areRulesRemoved = e.removeGroupingPolicies(groupingRules);

RemoveFilteredGroupingPolicy()

RemoveFilteredGroupingPolicy видаляє правило спадкування ролей з поточної політики, можна вказати фільтри полів.

Наприклад:

Go

removed := e.RemoveFilteredGroupingPolicy(0, "alice")

Node.js

const removed = await e.removeFilteredGroupingPolicy(0, 'alice')

PHP

$removed = $e->removeFilteredGroupingPolicy(0, "alice");

Python

removed = e.remove_filtered_grouping_policy(0, "alice")

.NET

var removed = e.RemoveFilteredGroupingPolicy(0, "alice");
or
var removed = await e.RemoveFilteredGroupingPolicyAsync(0, "alice");

Rust

let removed = e.remove_filtered_grouping_policy(0, vec!["alice".to_owned()]).await?;

Java

boolean removed = e.removeFilteredGroupingPolicy(0, "alice");

RemoveNamedGroupingPolicy()

RemoveNamedGroupingPolicy видаляє правило спадкування ролей з поточної іменованої політики.

Наприклад:

Go

removed := e.RemoveNamedGroupingPolicy("g", "alice")

Node.js

const removed = await e.removeNamedGroupingPolicy('g', 'alice')

PHP

$removed = $e->removeNamedGroupingPolicy("g", "alice");

Python

removed = e.remove_named_grouping_policy("g", "alice", "data2_admin")

.NET

var removed = e.RemoveNamedGroupingPolicy("g", "alice");
or 
var removed = await e.RemoveNamedGroupingPolicyAsync("g", "alice");

Rust

let removed = e.remove_named_grouping_policy("g", vec!["alice".to_owned()]).await?;

Java

boolean removed = e.removeNamedGroupingPolicy("g", "alice");

RemoveNamedGroupingPolicies()

RemoveNamedGroupingPolicies видаляє іменовані правила спадкування ролей з поточної політики. Операція є атомарною за своєю природою. Отже, якщо правила авторизації складаються з правил, які не відповідають поточній політиці, функція повертає false, і жодне правило політики не видаляється з поточної політики. Якщо всі правила авторизації відповідають правилам політики, функція повертає true, і кожне правило політики видаляється з поточної політики.

Наприклад:

Go

rules := [][] string {
    []string {"ham", "data4_admin"},
    []string {"jack", "data5_admin"},
}

areRulesRemoved := e.RemoveNamedGroupingPolicies("g", rules)

Node.js

const groupingRules = [
    ['ham', 'data4_admin'],
    ['jack', 'data5_admin']
  ];

const areRulesRemoved = await e.removeNamedGroupingPolicies('g', groupingRules);

Python

rules = [
    ["ham", "data4_admin"],
    ["jack", "data5_admin"]
]
are_rules_removed = e.remove_named_grouping_policies("g", rules)

Rust

let rules = vec![
    vec!["ham".to_owned(), "data4_admin".to_owned()],
    vec!["jack".to_owned(), "data5_admin".to_owned()],
];

let are_rules_removed = e.remove_named_grouping_policies("g", rules).await?;

Java

String[][] groupingRules = {
    {"ham", "data4_admin"},
    {"jack", "data5_admin"}
};
boolean areRulesRemoved = e.removeNamedGroupingPolicies("g", groupingRules);

RemoveFilteredNamedGroupingPolicy()

RemoveFilteredNamedGroupingPolicy видаляє правило спадкування ролей з поточної іменованої політики, можуть бути вказані фільтри полів.

Наприклад:

Go

removed := e.RemoveFilteredNamedGroupingPolicy("g", 0, "alice")

Node.js

const removed = await e.removeFilteredNamedGroupingPolicy('g', 0, 'alice')

PHP

$removed = $e->removeFilteredNamedGroupingPolicy("g", 0, "alice");

Python

removed = e.remove_filtered_named_grouping_policy("g", 0, "alice")

.NET

var removed = e.RemoveFilteredNamedGroupingPolicy("g", 0, "alice");
or
var removed = await e.RemoveFilteredNamedGroupingPolicyAsync("g", 0, "alice");

Rust

let removed = e.remove_filtered_named_groupingPolicy("g", 0, vec!["alice".to_owned()]).await?;

Java

boolean removed = e.removeFilteredNamedGroupingPolicy("g", 0, "alice");

UpdatePolicy()

UpdatePolicy оновлює стару політику на нову політику.

Наприклад:

Go

updated, err := e.UpdatePolicy([]string{"eve", "data3", "read"}, []string{"eve", "data3", "write"})

Node.js

const update = await e.updatePolicy(["eve", "data3", "read"], ["eve", "data3", "write"]);

Python

updated = e.update_policy(["eve", "data3", "read"], ["eve", "data3", "write"])

Java

boolean updated = e.updatePolicy(Arrays.asList("eve", "data3", "read"), Arrays.asList("eve", "data3", "write"));

UpdatePolicies()

UpdatePolicies оновлює всі старі політики на нові політики.

Наприклад:

Go

updated, err := e.UpdatePolicies([][]string{{"eve", "data3", "read"}, {"jack", "data3", "read"}}, [][]string{{"eve", "data3", "write"}, {"jack", "data3", "write"}})

Python

old_rules = [["eve", "data3", "read"], ["jack", "data3", "read"]]
new_rules = [["eve", "data3", "write"], ["jack", "data3", "write"]]

updated = e.update_policies(old_rules, new_rules)

AddFunction()

AddFunction додає користувацьку функцію.

Наприклад:

Go

func CustomFunction(key1 string, key2 string) bool {
    if key1 == "/alice_data2/myid/using/res_id" && key2 == "/alice_data/:resource" {
        return true
    } else if key1 == "/alice_data2/myid/using/res_id" && key2 == "/alice_data2/:id/using/:resId" {
        return true
    } else {
        return false
    }
}

func CustomFunctionWrapper(args ...interface{}) (interface{}, error) {
    key1 := args[0].(string)
    key2 := args[1].(string)

    return bool(CustomFunction(key1, key2)), nil
}

e.AddFunction("keyMatchCustom", CustomFunctionWrapper)

Node.js

function customFunction(key1, key2){
    if(key1 == "/alice_data2/myid/using/res_id" && key2 == "/alice_data/:resource") {
        return true
    } else if(key1 == "/alice_data2/myid/using/res_id" && key2 == "/alice_data2/:id/using/:resId") {
        return true
    } else {
        return false
    }
}

e.addFunction("keyMatchCustom", customFunction);

PHP

func customFunction($key1, $key2) {
    if ($key1 == "/alice_data2/myid/using/res_id" && $key2 == "/alice_data/:resource") {
        return true;
    } elseif ($key1 == "/alice_data2/myid/using/res_id" && $key2 == "/alice_data2/:id/using/:resId") {
        return true;
    } else {
        return false;
    }
}

func customFunctionWrapper(...$args){
    $key1 := $args[0];
    $key2 := $args[1];

    return customFunction($key1, $key2);
}

$e->addFunction("keyMatchCustom", customFunctionWrapper);

Python

def custom_function(key1, key2):
    return ((key1 == "/alice_data2/myid/using/res_id" and key2 == "/alice_data/:resource") or (key1 == "/alice_data2/myid/using/res_id" and key2 == "/alice_data2/:id/using/:resId"))


e.add_function("keyMatchCustom", custom_function)

Rust

fn custom_function(key1: STring, key2: String) {
    key1 == "/alice_data2/myid/using/res_id" && key2 == "/alice_data/:resource" || key1 == "/alice_data2/myid/using/res_id" && key2 == "/alice_data2/:id/using/:resId"
}


e.add_function("keyMatchCustom", custom_function);

Java

public static class CustomFunc extends CustomFunction {
    @Override
    public AviatorObject call(Map<String, Object> env, AviatorObject arg1, AviatorObject arg2) {
        String key1 = FunctionUtils.getStringValue(arg1, env);
        String key2 = FunctionUtils.getStringValue(arg2, env);
        if (key1.equals("/alice_data2/myid/using/res_id") && key2.equals("/alice_data/:resource")) {
            return AviatorBoolean.valueOf(true);
        } else if (key1.equals("/alice_data2/myid/using/res_id") && key2.equals("/alice_data2/:id/using/:resId")) {
            return AviatorBoolean.valueOf(true);
        } else {
            return AviatorBoolean.valueOf(false);
        }
    }

    @Override
    public String getName() {
        return "keyMatchCustom";
    }
}

FunctionTest.CustomFunc customFunc = new FunctionTest.CustomFunc();
e.addFunction(customFunc.getName(), customFunc);

LoadFilteredPolicy()

LoadFilteredPolicy завантажує відфільтровані політики з файлу/бази даних.

Наприклад:

Go

err := e.LoadFilteredPolicy()

Node.js

const ok = await e.loadFilteredPolicy();

Python

class Filter:
    P = []
    G = []

adapter = casbin.persist.adapters.FilteredAdapter("rbac_with_domains_policy.csv")
e = casbin.Enforcer("rbac_with_domains_model.conf", adapter)
filter = Filter()
filter.P = ["", "domain1"]
filter.G = ["", "", "domain1"]
e.load_filtered_policy(filter)

Java

e.loadFilteredPolicy(new String[] { "", "domain1" });

LoadIncrementalFilteredPolicy()

LoadIncrementalFilteredPolicy додає відфільтровану політику з файлу/бази даних.

Наприклад:

Go

err := e.LoadIncrementalFilteredPolicy()

Node.js

const ok = await e.loadIncrementalFilteredPolicy();

Python

adapter = casbin.persist.adapters.FilteredAdapter("rbac_with_domains_policy.csv")
e = casbin.Enforcer("rbac_with_domains_model.conf", adapter)
filter = Filter()
filter.P = ["", "domain1"]
filter.G = ["", "", "domain1"]
e.load_increment_filtered_policy(filter)

UpdateGroupingPolicy()

UpdateGroupingPolicy оновлює oldRule на newRule в секції g

Наприклад:

Go

succeed, err : = e.UpdateGroupingPolicy([]string{"data3_admin", "data4_admin"}, []string{"admin", "data4_admin"})

Java

boolean succeed = e.updateGroupingPolicy(Arrays.asList("data3_admin", "data4_admin"), Arrays.asList("admin", "data4_admin"));

UpdateNamedGroupingPolicy()

UpdateNamedGroupingPolicy оновлює oldRule з іменем ptype на newRule в секції g

Наприклад:

Go

succeed, err : = e.UpdateGroupingPolicy("g1",[]string{"data3_admin", "data4_admin"}, []string{"admin", "data4_admin"})

Java

boolean succeed = e.updateNamedGroupingPolicy("g1", Arrays.asList("data3_admin", "data4_admin"), Arrays.asList("admin", "data4_admin"));

SetFieldIndex()

SetFieldIndex підтримує налаштування звичайного імені та позиції sub, obj, domain та priority.

[policy_definition]
p = customized_priority, obj, act, eft, subject

Наприклад:

Go

e.SetFieldIndex("p", constant.PriorityIndex, 0)
e.SetFieldIndex("p", constant.SubjectIndex, 4)