Management API

Die primitive API, die volle Unterstützung für das Casbin-Richtlinienmanagement bietet.

Filtered API

Fast alle gefilterten APIs haben die gleichen Parameter (fieldIndex int, fieldValues ...string). fieldIndex ist der Index, an dem die Übereinstimmung beginnt, fieldValues bezeichnet die Werte, die das Ergebnis haben sollte. Beachten Sie, dass ein leerer String in fieldValues jedes Wort sein könnte.

Beispiel:

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

Referenz

Die globale Variable e ist eine Enforcer-Instanz.

Go

e, err := NewEnforcer("examples/rbac_model.conf", "examples/rbac_policy.csv")

Node.js

const e = await newEnforcer('examples/rbac_model.conf', 'examples/rbac_policy.csv')

PHP

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

Python

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

.NET

var e = new Enforcer("path/to/model.conf", "path/to/policy.csv");

Rust

let mut e = 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 entscheidet, ob ein "Subjekt" auf ein "Objekt" mit der Operation "Aktion" zugreifen kann, die Eingabeparameter sind in der Regel: (sub, obj, act).

Zum Beispiel:

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 verwendet einen benutzerdefinierten Matcher, um zu entscheiden, ob ein "Subjekt" auf ein "Objekt" mit der Operation "Aktion" zugreifen kann, die Eingabeparameter sind in der Regel: (matcher, sub, obj, act), verwendet standardmäßig den Modell-Matcher, wenn der Matcher "" ist.

Zum Beispiel:

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 erklärt die Durchsetzung, indem es über übereinstimmende Regeln informiert.

Zum Beispiel:

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 verwendet einen benutzerdefinierten Matcher und erklärt die Durchsetzung, indem es über übereinstimmende Regeln informiert.

Zum Beispiel:

Go

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

BatchEnforce()

BatchEnforce setzt jede Anforderung durch und gibt das Ergebnis in einem boolschen Array zurück

Zum Beispiel:

Go

boolArray, err := e.BatchEnforce(requests)

Node.js

const boolArray = await e.batchEnforce(requests);

Java

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

GetAllSubjects()

GetAllSubjects erhält die Liste der Subjekte, die in der aktuellen Richtlinie auftauchen.

Zum Beispiel:

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 erhält die Liste der Subjekte, die in der aktuellen benannten Richtlinie auftauchen.

Zum Beispiel:

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 erhält die Liste der Objekte, die in der aktuellen Richtlinie auftauchen.

Zum Beispiel:

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 erhält die Liste der Objekte, die in der aktuellen benannten Richtlinie auftauchen.

Zum Beispiel:

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 erhält die Liste der Aktionen, die in der aktuellen Richtlinie auftauchen.

Zum Beispiel:

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 erhält die Liste der Aktionen, die in der aktuellen benannten Richtlinie auftauchen.

Zum Beispiel:

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 holt die Liste der Rollen, die in der aktuellen Richtlinie erscheinen.

Zum Beispiel:

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 holt die Liste der Rollen, die in der aktuellen benannten Richtlinie erscheinen.

Zum Beispiel:

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 holt alle Autorisierungsregeln in der Richtlinie.

Zum Beispiel:

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 holt alle Autorisierungsregeln in der Richtlinie, Feldfilter können angegeben werden.

Zum Beispiel:

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 holt alle Autorisierungsregeln in der benannten Richtlinie.

Zum Beispiel:

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 holt alle Autorisierungsregeln in der benannten Richtlinie, Feldfilter können angegeben werden.

Zum Beispiel:

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 holt alle Rollenvererbungsregeln in der Richtlinie.

Zum Beispiel:

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 holt alle Rollenvererbungsregeln in der Richtlinie, Feldfilter können angegeben werden.

Zum Beispiel:

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 holt alle Rollenvererbungsregeln in der Richtlinie.

Zum Beispiel:

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 holt alle Rollenvererbungsregeln in der Richtlinie.

Zum Beispiel:

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 bestimmt, ob eine Autorisierungsregel existiert.

Zum Beispiel:

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 bestimmt, ob eine benannte Autorisierungsregel existiert.

Zum Beispiel:

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 fügt eine Autorisierungsregel zur aktuellen Richtlinie hinzu. Wenn die Regel bereits existiert, gibt die Funktion false zurück und die Regel wird nicht hinzugefügt. Andernfalls gibt die Funktion true zurück, indem die neue Regel hinzugefügt wird.

Zum Beispiel:

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 fügt Autorisierungsregeln zur aktuellen Richtlinie hinzu. Die Operation ist atomar. Daher, wenn Autorisierungsregeln aus Regeln bestehen, die nicht mit der aktuellen Richtlinie übereinstimmen, gibt die Funktion false zurück und keine Richtlinienregel wird zur aktuellen Richtlinie hinzugefügt. Wenn alle Autorisierungsregeln mit den Richtlinienregeln übereinstimmen, gibt die Funktion true zurück und jede Richtlinienregel wird zur aktuellen Richtlinie hinzugefügt.

Zum Beispiel:

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 fügt Autorisierungsregeln zur aktuellen Richtlinie hinzu. Wenn die Regel bereits existiert, wird die Regel nicht hinzugefügt. Aber im Gegensatz zu AddPolicies werden andere nicht existierende Regeln hinzugefügt, anstatt direkt false zurückzugeben

Zum Beispiel:

Go

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

AddNamedPolicy()

AddNamedPolicy fügt eine Autorisierungsregel zur aktuellen benannten Richtlinie hinzu. Wenn die Regel bereits existiert, gibt die Funktion false zurück und die Regel wird nicht hinzugefügt. Andernfalls gibt die Funktion true zurück, indem die neue Regel hinzugefügt wird.

Zum Beispiel:

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 fügt Autorisierungsregeln zur aktuellen benannten Richtlinie hinzu. Die Operation ist atomar. Daher, wenn Autorisierungsregeln aus Regeln bestehen, die nicht mit der aktuellen Richtlinie übereinstimmen, gibt die Funktion false zurück und keine Richtlinienregel wird zur aktuellen Richtlinie hinzugefügt. Wenn alle Autorisierungsregeln mit den Richtlinienregeln übereinstimmen, gibt die Funktion true zurück und jede Richtlinienregel wird zur aktuellen Richtlinie hinzugefügt.

Zum Beispiel:

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 fügt Autorisierungsregeln zur aktuellen benannten Richtlinie hinzu. Wenn die Regel bereits existiert, wird die Regel nicht hinzugefügt. Aber im Gegensatz zu AddNamedPolicies werden andere nicht existierende Regeln hinzugefügt, anstatt direkt false zurückzugeben

Zum Beispiel:

Go

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

SelfAddPoliciesEx()

SelfAddPoliciesEx fügt Autorisierungsregeln zur aktuellen benannten Richtlinie hinzu, wobei autoNotifyWatcher deaktiviert ist. Wenn die Regel bereits existiert, wird die Regel nicht hinzugefügt. Aber im Gegensatz zu SelfAddPolicies werden andere nicht existierende Regeln hinzugefügt, anstatt direkt false zurückzugeben

Zum Beispiel:

Go

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

RemovePolicy()

RemovePolicy entfernt eine Autorisierungsregel aus der aktuellen Richtlinie.

Zum Beispiel:

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 entfernt Autorisierungsregeln aus der aktuellen Richtlinie. Die Operation ist atomar. Daher, wenn Autorisierungsregeln aus Regeln bestehen, die nicht mit der aktuellen Richtlinie übereinstimmen, gibt die Funktion false zurück und keine Richtlinienregel wird aus der aktuellen Richtlinie entfernt. Wenn alle Autorisierungsregeln mit den Richtlinienregeln übereinstimmen, gibt die Funktion true zurück und jede Richtlinienregel wird aus der aktuellen Richtlinie entfernt.

Zum Beispiel:

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 entfernt eine Autorisierungsregel aus der aktuellen Richtlinie, Feldfilter können angegeben werden. RemovePolicy entfernt eine Autorisierungsregel aus der aktuellen Richtlinie.

Zum Beispiel:

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 entfernt eine Autorisierungsregel aus der aktuellen benannten Richtlinie.

Zum Beispiel:

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 entfernt Autorisierungsregeln aus der aktuellen benannten Richtlinie. Die Operation ist atomar. Wenn die Autorisierungsregeln aus Regeln bestehen, die nicht mit der aktuellen Richtlinie übereinstimmen, gibt die Funktion false zurück und keine Richtlinienregel wird aus der aktuellen Richtlinie entfernt. Wenn alle Autorisierungsregeln mit den Richtlinienregeln übereinstimmen, gibt die Funktion true zurück und jede Richtlinienregel wird aus der aktuellen Richtlinie entfernt.

Zum Beispiel:

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 entfernt eine Autorisierungsregel aus der aktuellen benannten Richtlinie, Feldfilter können angegeben werden.

Zum Beispiel:

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 bestimmt, ob eine Regel für die Rollenvererbung existiert.

Zum Beispiel:

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 bestimmt, ob eine benannte Regel für die Rollenvererbung existiert.

Zum Beispiel:

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 fügt eine Regel für die Rollenvererbung zur aktuellen Richtlinie hinzu. Wenn die Regel bereits existiert, gibt die Funktion false zurück und die Regel wird nicht hinzugefügt. Andernfalls gibt die Funktion true zurück, indem die neue Regel hinzugefügt wird.

Zum Beispiel:

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 fügt Regeln für die Rollenvererbung zur aktuellen Richtlinie hinzu. Die Operation ist atomar. Wenn die Autorisierungsregeln aus Regeln bestehen, die nicht mit der aktuellen Richtlinie übereinstimmen, gibt die Funktion false zurück und keine Richtlinienregel wird zur aktuellen Richtlinie hinzugefügt. Wenn alle Autorisierungsregeln mit den Richtlinienregeln übereinstimmen, gibt die Funktion true zurück und jede Richtlinienregel wird zur aktuellen Richtlinie hinzugefügt.

Zum Beispiel:

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 fügt Regeln für die Rollenvererbung zur aktuellen Richtlinie hinzu. Wenn die Regel bereits existiert, wird die Regel nicht hinzugefügt. Aber im Gegensatz zu AddGroupingPolicies werden andere nicht existierende Regeln hinzugefügt, anstatt direkt false zurückzugeben

Zum Beispiel:

Go

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

AddNamedGroupingPolicy()

AddNamedGroupingPolicy fügt eine benannte Rollenvererbungsregel zur aktuellen Richtlinie hinzu. Wenn die Regel bereits existiert, gibt die Funktion false zurück und die Regel wird nicht hinzugefügt. Andernfalls gibt die Funktion true zurück, indem die neue Regel hinzugefügt wird.

Zum Beispiel:

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 fügt benannte Rollenvererbungsregeln zur aktuellen Richtlinie hinzu. Die Operation ist atomar. Wenn also Autorisierungsregeln aus Regeln bestehen, die nicht mit der aktuellen Richtlinie übereinstimmen, gibt die Funktion false zurück und es wird keine Richtlinienregel zur aktuellen Richtlinie hinzugefügt. Wenn alle Autorisierungsregeln mit den Richtlinienregeln übereinstimmen, gibt die Funktion true zurück und jede Richtlinienregel wird zur aktuellen Richtlinie hinzugefügt.

Zum Beispiel:

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 fügt benannte Rollenvererbungsregeln zur aktuellen Richtlinie hinzu. Wenn die Regel bereits existiert, wird die Regel nicht hinzugefügt. Aber im Gegensatz zu AddNamedGroupingPolicies werden andere nicht existierende Regeln hinzugefügt, anstatt direkt false zurückzugeben

Zum Beispiel:

Go

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

RemoveGroupingPolicy()

RemoveGroupingPolicy entfernt eine Rollenvererbungsregel aus der aktuellen Richtlinie.

Zum Beispiel:

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 entfernt Rollenvererbungsregeln aus der aktuellen Richtlinie. Die Operation ist atomar. Wenn also Autorisierungsregeln aus Regeln bestehen, die nicht mit der aktuellen Richtlinie übereinstimmen, gibt die Funktion false zurück und es wird keine Richtlinienregel aus der aktuellen Richtlinie entfernt. Wenn alle Autorisierungsregeln mit den Richtlinienregeln übereinstimmen, gibt die Funktion true zurück und jede Richtlinienregel wird aus der aktuellen Richtlinie entfernt.

Zum Beispiel:

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 entfernt eine Rollenvererbungsregel aus der aktuellen Richtlinie, Feldfilter können angegeben werden.

Zum Beispiel:

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 entfernt eine Rollenvererbungsregel aus der aktuellen benannten Richtlinie.

Zum Beispiel:

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 entfernt benannte Rollenvererbungsregeln aus der aktuellen Richtlinie. Die Operation ist atomar. Wenn also Autorisierungsregeln aus Regeln bestehen, die nicht mit der aktuellen Richtlinie übereinstimmen, gibt die Funktion false zurück und es wird keine Richtlinienregel aus der aktuellen Richtlinie entfernt. Wenn alle Autorisierungsregeln mit den Richtlinienregeln übereinstimmen, gibt die Funktion true zurück und jede Richtlinienregel wird aus der aktuellen Richtlinie entfernt.

Zum Beispiel:

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 entfernt eine Rollenvererbungsregel aus der aktuellen benannten Richtlinie, Feldfilter können angegeben werden.

Zum Beispiel:

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 aktualisiert eine alte Richtlinie zu einer neuen Richtlinie.

Zum Beispiel:

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 aktualisiert alle alten Richtlinien zu neuen Richtlinien.

Zum Beispiel:

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 fügt eine benutzerdefinierte Funktion hinzu.

Zum Beispiel:

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 lädt gefilterte Richtlinien aus Datei/Datenbank.

Zum Beispiel:

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 fügt eine gefilterte Richtlinie aus Datei/Datenbank hinzu.

Zum Beispiel:

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 aktualisiert oldRule zu newRulein im g Abschnitt

Zum Beispiel:

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 aktualisiert oldRule namens ptype zu newRulein im g Abschnitt

Zum Beispiel:

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 unterstützt die Anpassung von konventionellem Namen und Position von sub, obj, domain und priority.

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

Zum Beispiel:

Go

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