Management API

The primitive API that provides full support for Casbin policy management.

Filtered API

Almost all filtered api has the same parameters (fieldIndex int, fieldValues ...string). fieldIndex is the index where matching start, fieldValues denotes the values result should have. Note that empty string in fieldValues could be any word.

Example:

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]]

Reference

global variable e is Enforcer instance.

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 decides whether a "subject" can access a "object" with the operation "action", input parameters are usually: (sub, obj, act).

For example:

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 use a custom matcher to decides whether a "subject" can access a "object" with the operation "action", input parameters are usually: (matcher, sub, obj, act), use model matcher by default when matcher is "".

For example:

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 explain enforcement by informing matched rules.

For example:

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 use a custom matcher and explain enforcement by informing matched rules.

For example:

Go

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

BatchEnforce()

BatchEnforce enforces each request and returns result in a bool array

For example:

Go

boolArray, err := e.BatchEnforce(requests)

Node.js

const boolArray = await e.batchEnforce(requests);

Java

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

GetAllSubjects()

GetAllSubjects gets the list of subjects that show up in the current policy.

For example:

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 gets the list of subjects that show up in the current named policy.

For example:

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 gets the list of objects that show up in the current policy.

For example:

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 gets the list of objects that show up in the current named policy.

For example:

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 gets the list of actions that show up in the current policy.

For example:

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 gets the list of actions that show up in the current named policy.

For example:

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 gets the list of roles that show up in the current policy.

For example:

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 gets the list of roles that show up in the current named policy.

For example:

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 gets all the authorization rules in the policy.

For example:

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 gets all the authorization rules in the policy, field filters can be specified.

For example:

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 gets all the authorization rules in the named policy.

For example:

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 gets all the authorization rules in the named policy, field filters can be specified.

For example:

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 gets all the role inheritance rules in the policy.

For example:

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 gets all the role inheritance rules in the policy, field filters can be specified.

For example:

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 gets all the role inheritance rules in the policy.

For example:

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 gets all the role inheritance rules in the policy.

For example:

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 determines whether an authorization rule exists.

For example:

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 determines whether a named authorization rule exists.

For example:

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 adds an authorization rule to the current policy. If the rule already exists, the function returns false and the rule will not be added. Otherwise the function returns true by adding the new rule.

For example:

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 adds authorization rules to the current policy. The operation is atomic in nature. Hence, if authorization rules consists of rules which are not consistent with the current policy, the function returns false and no policy rule is added to the current policy. If all the authorization rules are consistent with the policy rules, the function returns true and each policy rule is added to the current policy.

For example:

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 adds authorization rules to the current policy. If the rule already exists, the rule will not be added. But unlike AddPolicies, other non-existent rules are added instead of returning false directly

For example:

Go

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

AddNamedPolicy()

AddNamedPolicy adds an authorization rule to the current named policy. If the rule already exists, the function returns false and the rule will not be added. Otherwise the function returns true by adding the new rule.

For example:

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 adds authorization rules to the current named policy. The operation is atomic in nature. Hence, if authorization rules consists of rules which are not consistent with the current policy, the function returns false and no policy rule is added to the current policy. If all the authorization rules are consistent with the policy rules, the function returns true and each policy rule is added to the current policy.

For example:

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 adds authorization rules to the current named policy. If the rule already exists, the rule will not be added. But unlike AddNamedPolicies, other non-existent rules are added instead of returning false directly

For example:

Go

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

SelfAddPoliciesEx()

SelfAddPoliciesEx adds authorization rules to the current named policy with autoNotifyWatcher disabled. If the rule already exists, the rule will not be added. But unlike SelfAddPolicies, other non-existent rules are added instead of returning false directly

For example:

Go

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

RemovePolicy()

RemovePolicy removes an authorization rule from the current policy.

For example:

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 removes authorization rules from the current policy. The operation is atomic in nature. Hence, if authorization rules consists of rules which are not consistent with the current policy, the function returns false and no policy rule is removed from the current policy. If all the authorization rules are consistent with the policy rules, the function returns true and each policy rule is removed from the current policy.

For example:

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 removes an authorization rule from the current policy, field filters can be specified. RemovePolicy removes an authorization rule from the current policy.

For example:

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 removes an authorization rule from the current named policy.

For example:

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 removes authorization rules from the current named policy. The operation is atomic in nature. Hence, if authorization rules consists of rules which are not consistent with the current policy, the function returns false and no policy rule is removed from the current policy. If all the authorization rules are consistent with the policy rules, the function returns true and each policy rule is removed from the current policy.

For example:

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 removes an authorization rule from the current named policy, field filters can be specified.

For example:

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 determines whether a role inheritance rule exists.

For example:

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 determines whether a named role inheritance rule exists.

For example:

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 adds a role inheritance rule to the current policy. If the rule already exists, the function returns false and the rule will not be added. Otherwise the function returns true by adding the new rule.

For example:

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 adds role inheritance rules to the current policy. The operation is atomic in nature. Hence, if authorization rules consists of rules which are not consistent with the current policy, the function returns false and no policy rule is added to the current policy. If all authorization the rules are consistent with the policy rules, the function returns true and each policy rule is added to the current policy.

For example:

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 adds role inheritance rules to the current policy. If the rule already exists, the rule will not be added. But unlike AddGroupingPolicies, other non-existent rules are added instead of returning false directly

For example:

Go

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

AddNamedGroupingPolicy()

AddNamedGroupingPolicy adds a named role inheritance rule to the current policy. If the rule already exists, the function returns false and the rule will not be added. Otherwise the function returns true by adding the new rule.

For example:

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 adds named role inheritance rules to the current policy. The operation is atomic in nature. Hence, if authorization rules consists of rules which are not consistent with the current policy, the function returns false and no policy rule is added to the current policy. If all the authorization rules are consistent with the policy rules, the function returns true and each policy rule is added to the current policy.

For example:

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 adds named role inheritance rules to the current policy. If the rule already exists, the rule will not be added. But unlike AddNamedGroupingPolicies, other non-existent rules are added instead of returning false directly

For example:

Go

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

RemoveGroupingPolicy()

RemoveGroupingPolicy removes a role inheritance rule from the current policy.

For example:

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 removes role inheritance rules from the current policy. The operation is atomic in nature. Hence, if authorization rules consists of rules which are not consistent with the current policy, the function returns false and no policy rule is removed from the current policy. If all the authorization rules are consistent with the policy rules, the function returns true and each policy rule is removed from the current policy.

For example:

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 removes a role inheritance rule from the current policy, field filters can be specified.

For example:

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 removes a role inheritance rule from the current named policy.

For example:

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 removes named role inheritance rules from the current policy. The operation is atomic in nature. Hence, if authorization rules consists of rules which are not consistent with the current policy, the function returns false and no policy rule is removed from the current policy. If all the authorization rules are consistent with the policy rules, the function returns true and each policy rule is removed from the current policy.

For example:

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 removes a role inheritance rule from the current named policy, field filters can be specified.

For example:

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 update a old policy to new policy.

For example:

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 updates all old policies to new policies.

For example:

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 adds a customized function.

For example:

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 loads filtered policies from file/database.

For example:

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 append a filtered policy from file/database.

For example:

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 updates oldRule to newRulein g section

For example:

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 updates oldRule named ptype to newRulein g section

For example:

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 suport customization of conventional name and position of sub, obj, domain and priority.

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

For example:

Go

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