Management API

Casbin politikası yönetimi için tam destek sağlayan ilkel API.

Filtered API

Neredeyse tüm filtreli api'ler aynı parametrelere sahip: (fieldIndex int, fieldValues ...string). fieldIndex, eşleşmenin başladığı indekstir, fieldValues sonuçların sahip olması gereken değerleri belirtir. fieldValues içindeki boş string herhangi bir kelime olabilir.

Örnek:

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

Referans

global değişken e, Enforcer örneğidir.

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", bir "subject"ın "action" işlemiyle bir "object"a erişip erişemeyeceğine karar verir, genellikle girdi parametreleri şunlardır: (sub, obj, act).

Örneğin:

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, özel bir eşleştirici kullanarak bir "subject"ın "action" işlemiyle bir "object"a erişip erişemeyeceğine karar verir, genellikle girdi parametreleri şunlardır: (matcher, sub, obj, act), eşleştirici boş olduğunda varsayılan olarak model eşleştirici kullanılır.

Örneğin:

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, eşleşen kuralları bildirerek uygulamayı açıklar.

Örneğin:

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, özel bir eşleştirici kullanarak ve eşleşen kuralları bildirerek uygulamayı açıklar.

Örneğin:

Go

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

BatchEnforce()

BatchEnforce her isteği uygular ve sonucu bir bool dizisinde döndürür

Örneğin:

Go

boolArray, err := e.BatchEnforce(requests)

Node.js

const boolArray = await e.batchEnforce(requests);

Java

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

GetAllSubjects()

GetAllSubjects, mevcut politikada görünen konuların listesini alır.

Örneğin:

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, mevcut adlandırılmış politikada görünen konuların listesini alır.

Örneğin:

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, mevcut politikada görünen nesnelerin listesini alır.

Örneğin:

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, mevcut adlandırılmış politikada görünen nesnelerin listesini alır.

Örneğin:

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, mevcut politikada görünen eylemlerin listesini alır.

Örneğin:

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, geçerli adlandırılmış politikada görünen eylemlerin listesini alır.

Örneğin:

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, geçerli politikada görünen rolleri listeler.

Örneğin:

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, geçerli adlandırılmış politikada görünen rolleri listeler.

Örneğin:

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, politikadaki tüm yetkilendirme kurallarını alır.

Örneğin:

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, politikadaki tüm yetkilendirme kurallarını alır, alan filtreleri belirtilebilir.

Örneğin:

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, adlandırılmış politikadaki tüm yetkilendirme kurallarını alır.

Örneğin:

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, adlandırılmış politikadaki tüm yetkilendirme kurallarını alır, alan filtreleri belirtilebilir.

Örneğin:

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, politikadaki tüm rol miras kurallarını alır.

Örneğin:

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, politikadaki tüm rol miras kurallarını alır, alan filtreleri belirtilebilir.

Örneğin:

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, politikadaki tüm rol miras kurallarını alır.

Örneğin:

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, politikadaki tüm rol miras kurallarını alır.

Örneğin:

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, bir yetkilendirme kuralının var olup olmadığını belirler.

Örneğin:

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, adlandırılmış bir yetkilendirme kuralının var olup olmadığını belirler.

Örneğin:

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, mevcut politikaya bir yetkilendirme kuralı ekler. Eğer kural zaten mevcutsa, fonksiyon false döner ve kural eklenmez. Aksi takdirde, fonksiyon yeni kuralı ekleyerek true döner.

Örneğin:

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, yetkilendirme kurallarını mevcut politikaya ekler. İşlem doğası gereği atomiktir. Bu nedenle, eğer yetkilendirme kuralları mevcut politikayla tutarsız olan kurallardan oluşuyorsa, fonksiyon false döner ve hiçbir politikaya kural eklenmez. Eğer tüm yetkilendirme kuralları politikanın kurallarıyla tutarlıysa, fonksiyon true döner ve her bir politikaya kural eklenir.

Örneğin:

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, yetkilendirme kurallarını mevcut politikaya ekler. Eğer kural zaten mevcutsa, kural eklenmeyecektir. Ancak AddPolicies'ten farklı olarak, diğer mevcut olmayan kurallar eklenir ve doğrudan false döndürülmez.

Örneğin:

Go

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

AddNamedPolicy()

AddNamedPolicy, bir yetkilendirme kuralını mevcut adlandırılmış politikaya ekler. Eğer kural zaten mevcutsa, fonksiyon false döndürür ve kural eklenmez. Aksi takdirde, fonksiyon yeni kuralı ekleyerek true döndürür.

Örneğin:

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, mevcut adlandırılmış politikaya yetkilendirme kuralları ekler. İşlem, doğası gereği atomiktir. Bu nedenle, eğer yetkilendirme kuralları, mevcut politikayla tutarsız olan kurallardan oluşuyorsa, fonksiyon false döner ve hiçbir politika kuralı mevcut politika eklenmez. Eğer tüm yetkilendirme kuralları politikanın kurallarıyla tutarlıysa, fonksiyon true döner ve her politika kuralı mevcut politika eklenir.

Örneğin:

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, mevcut adlandırılmış politikaya yetkilendirme kuralları ekler. Eğer kural zaten varsa, kural eklenmez. Ancak AddNamedPolicies'ten farklı olarak, diğer mevcut olmayan kurallar eklenir ve doğrudan false dönülmez.

Örneğin:

Go

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

SelfAddPoliciesEx()

SelfAddPoliciesEx, autoNotifyWatcher devre dışı bırakılarak geçerli adlandırılmış politikaya yetkilendirme kuralları ekler. Eğer kural zaten mevcutsa, kural eklenmeyecektir. Ancak SelfAddPolicies'ten farklı olarak, diğer mevcut olmayan kurallar doğrudan false döndürmek yerine eklenir.

Örneğin:

Go

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

RemovePolicy()

RemovePolicy, geçerli politikadan bir yetkilendirme kuralını kaldırır.

Örneğin:

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, geçerli politikadan yetkilendirme kurallarını kaldırır. İşlem, doğası gereği atomiktir. Bu nedenle, yetkilendirme kuralları mevcut politikayla tutarsız olan kurallardan oluşuyorsa, fonksiyon yanlış döner ve hiçbir politikaya ait kural mevcut politikadan kaldırılmaz. Eğer tüm yetkilendirme kuralları politikaya uygun ise, fonksiyon doğru döner ve her bir politikaya ait kural mevcut politikadan kaldırılır.

Örneğin:

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, mevcut politikadan bir yetkilendirme kuralını kaldırır, alan filtreleri belirtilebilir. RemovePolicy, mevcut politikadan bir yetkilendirme kuralını kaldırır.

Örneğin:

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, mevcut adlandırılmış politikadan bir yetkilendirme kuralını kaldırır.

Örneğin:

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, mevcut adlandırılmış politikadan yetkilendirme kurallarını kaldırır. İşlem, doğası gereği atomiktir. Bu nedenle, yetkilendirme kuralları mevcut politikayla tutarsız olan kurallardan oluşuyorsa, fonksiyon false döner ve hiçbir politikaya ait kural kaldırılmaz. Eğer tüm yetkilendirme kuralları politikaya uygunsa, fonksiyon true döner ve her politikaya ait kural kaldırılır.

Örneğin:

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, mevcut adlandırılmış politikadan bir yetkilendirme kuralını kaldırır, alan filtreleri belirtilebilir.

Örneğin:

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, bir rol miras kuralının var olup olmadığını belirler.

Örneğin:

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, adlandırılmış bir rol miras kuralının var olup olmadığını belirler.

Örneğin:

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, mevcut politikaya bir rol miras kuralı ekler. Eğer kural zaten varsa, fonksiyon false döner ve kural eklenmez. Aksi takdirde fonksiyon, yeni kuralı ekleyerek true döner.

Örneğin:

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, rol miras kurallarını mevcut politikaya ekler. İşlem doğası gereği atomiktir. Bu nedenle, yetkilendirme kuralları mevcut politikayla tutarsız olan kurallardan oluşuyorsa, fonksiyon false döner ve hiçbir politikaya kural eklenmez. Eğer tüm yetkilendirme kuralları politikaya uygunsa, fonksiyon true döner ve her politikaya kural eklenir.

Örneğin:

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, rol miras kurallarını mevcut politikaya ekler. Eğer kural zaten mevcutsa, kural eklenmez. Ancak AddGroupingPolicies'ten farklı olarak, diğer mevcut olmayan kurallar doğrudan false döndürmek yerine eklenir.

Örneğin:

Go

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

AddNamedGroupingPolicy()

AddNamedGroupingPolicy, mevcut politikaya adlandırılmış bir rol miras kurallı ekler. Eğer kural zaten mevcutsa, fonksiyon false döner ve kural eklenmez. Aksi takdirde fonksiyon, yeni kuralı ekleyerek true döner.

Örneğin:

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, mevcut politikaya adlandırılmış rol miras kuralları ekler. İşlem, doğası gereği atomiktir. Bu nedenle, yetkilendirme kuralları mevcut politikayla tutarsız olan kurallardan oluşuyorsa, fonksiyon yanlış döner ve hiçbir politikaya kural eklenmez. Eğer tüm yetkilendirme kuralları politikaya uygunsa, fonksiyon doğru döner ve her politikaya kural mevcut politikaya eklenir.

Örneğin:

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, adlandırılmış rol miras kurallarını mevcut politika için ekler. Eğer kural zaten varsa, kural eklenmez. Ancak AddNamedGroupingPolicies'ten farklı olarak, diğer mevcut olmayan kurallar doğrudan yanlış dönmek yerine eklenir.

Örneğin:

Go

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

RemoveGroupingPolicy()

RemoveGroupingPolicy, bir rol miras kuralını mevcut politikadan kaldırır.

Örneğin:

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, mevcut politikadan rol miras kurallarını kaldırır. İşlem doğası gereği atomiktir. Bu nedenle, yetkilendirme kuralları mevcut politikayla tutarsız olan kurallardan oluşuyorsa, fonksiyon false döner ve hiçbir politika kuralı mevcut politikadan kaldırılmaz. Eğer tüm yetkilendirme kuralları politika kurallarıyla tutarlıysa, fonksiyon true döner ve her politika kuralı mevcut politikadan kaldırılır.

Örneğin:

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, mevcut politikadan bir rol miras kuralını kaldırır, alan filtreleri belirtilebilir.

Örneğin:

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, mevcut adlandırılmış politikadan bir rol kalıtım kuralını kaldırır.

Örneğin:

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, mevcut politikadan adlandırılmış rol kalıtım kurallarını kaldırır. İşlem doğası gereği atomiktir. Bu nedenle, yetkilendirme kuralları mevcut politikayla tutarsız olan kurallardan oluşuyorsa, fonksiyon false döner ve hiçbir politikaya ait kural kaldırılmaz. Eğer tüm yetkilendirme kuralları politikaya uygunsa, fonksiyon true döner ve her bir politikaya ait kural mevcut politikadan kaldırılır.

Örneğin:

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, mevcut adlandırılmış politikadan bir rol miras kuralını kaldırır, alan filtreleri belirtilebilir.

Örneğin:

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, eski bir politikayı yeni bir politika olarak günceller.

Örneğin:

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, tüm eski politikaları yeni politikalara günceller.

Örneğin:

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, özelleştirilmiş bir fonksiyon ekler.

Örneğin:

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, filtrelenmiş politikaları dosya/veritabanından yükler.

Örneğin:

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, dosya/veritabanından filtrelenmiş bir politika ekler.

Örneğin:

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, g bölümündeki oldRule'u newRule ile günceller.

Örneğin:

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, eski ptype adlı kuralı g bölümünde yeniRule olarak günceller.

Örneğin:

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 ve priority için geleneksel ad ve pozisyonun özelleştirilmesini destekler.

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

Örneğin:

Go

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