Management-API · Casbin

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

Gefilterte API

Fast alle gefilterten api haben die gleichen Parameter (fieldIndex int, fieldValues ...string). fieldIndex ist der Index, in dem der übereinstimmende Anfang, fieldValues bezeichnet das Ergebnis, das Werte haben sollen. Beachten Sie, dass ein leerer String in Feldwerten ein beliebiges Wort sein kann.

Beispiel:

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

e.GetFilteredPolicy(1, "Buch") // wird zurückgegeben: [[Alice Book read] [Bob Book read] [Bob Book write]]

e. etFilteredPolicy(1, "book", "read") // gibt zurück: [[alice book read] [bob book read]]

e. etFilteredPolicy(0, "alice", "", "read") // wird zurückgegeben: [[alice book read]]

e.GetFilteredPolicy(0, "alice") // wird zurückgeben: [[alice book read] [alice pen get]]

Referenz

globale Variable e ist Enforcer Instanz.

Node.js

PHP

Python

.NET

Rust

Java

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

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

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

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

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

let mut e = Enforce::new("examples/rbac_model.conf", "examples/rbac_policy.csv").await?;

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

`Enforce()`

Enforce entscheidet, ob ein "Betreff" mit der Operation "action" auf ein "Objekt" zugreifen kann, die Eingabeparameter sind üblich: (sub, obj, act).

Zum Beispiel:

Node.js

PHP

Python

Java

ok, err := e.Enforce(request)

const ok = await e.enforce(request);

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

ok = e.enforcer(request)

boolean ok = e.enforce(request);

`EnforceWithMatcher()`

EnforceWithMatcher verwendet einen benutzerdefinierten Matcher um zu entscheiden, ob ein "Betreff" mit der Operation "Aktion" auf ein "Objekt" zugreifen kann Eingabeparameter sind üblich: (Matcher, Sub, obj, act), verwenden Sie standardmäßig Modellmatcher wenn der Matcher "" ist.

Zum Beispiel:

PHP

Python

Java

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

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

ok = e.enforce_with_matcher(matcher, request)

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

`EnforceEx()`

EnforceEx erklärt die Durchsetzung durch entsprechende Regeln.

Zum Beispiel:

Node.js

PHP

Python

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

const ok = await e.enforceEx(request);

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

ok, reason = e.enforce_ex(request)

`EnforceExWithMatcher()`

EnforceExWithMatcher verwenden einen benutzerdefinierten Matcher und erläutern die Durchsetzung durch Informationen über die entsprechenden Regeln.

Zum Beispiel:

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

`BatchEnforce()`

BatchErzwinge jede Anfrage und gibt Ergebnis in einem Bool-Array zurück

Zum Beispiel:

Node.js

Java

boolArray, err := e.BatchEnforce(requests)

const boolArray = await e.batchEnforce(requests);

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

`GetAllsubjects()`

GetAllSubjects bekommt die Liste der Themen, die in der aktuellen Richtlinie erscheinen.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

allSubjects := e.GetAllSubjects()

const allSubjects = await e.getAllSubjects()

$allSubjects = $e->getAllSubjects();

all_subjects = e.get_all_subjects()

var allSubjects = e.GetAllSubjects();

let all_subjects = e.get_all_subjects();

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

`GetAllNamedSubjects()`

GetAllNamedSubjects erhält die Liste der Themen, die in der aktuell benannten Richtlinie erscheinen.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

allNamedSubjects := e.GetAllNamedSubjects("p")

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

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

all_named_subjects = e.get_all_named_subjects("p")

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

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

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

`GetAllObjects()`

GetAllObjects erhält die Liste der Objekte, die in der aktuellen Richtlinie erscheinen.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

allObjects := e.GetAllObjects()

const allObjects = await e.getAllObjects()

$allObjects = $e->getAllObjects();

all_objects = e.get_all_objects()

var allObjects = e.GetAllObjects();

let all_objects = e.get_all_objects();

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

`GetAllNamedObjects()`

GetAllNamedObjects erhält die Liste der Objekte, die in den aktuell benannten Richtlinien erscheinen.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

allNamedObjects := e.GetAllNamedObjects("p")

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

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

all_named_objects = e.get_all_named_objects("p")

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

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

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

`GetAllActions()`

GetAllActions erhält die Liste der Aktionen, die in der aktuellen Richtlinie erscheinen.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

allActions := e.GetAllActions()

const allActions = await e.getAllActions()

$allActions = $e->getAllActions();

all_actions = e.get_all_actions()

var allActions = e.GetAllActions();

let all_actions = e.get_all_actions();

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

`GetAllNamedActions()`

GetAllNamedActions erhält die Liste der Aktionen, die in den aktuell benannten Richtlinien erscheinen.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

allNamedActions := e.GetAllNamedActions("p")

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

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

all_named_actions = e.get_all_named_actions("p")

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

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

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

`GetAllRoles()`

GetAllRoles erhält die Liste der Rollen, die in den aktuellen Richtlinien erscheinen.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

allRoles = e.GetAllRoles()

const allRoles = await e.getAllRoles()

$allRoles = $e->getAllRoles();

all_roles = e.get_all_roles()

var allRoles = e.GetAllRoles();

let all_roles = e.get_all_roles();

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

`GetAllNamedRoles()`

GetAllNamedRoles erhält die Liste der Rollen, die in den aktuell benannten Richtlinien erscheinen.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

allNamedRoles := e.GetAllNamedRoles("g")

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

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

all_named_roles = e.get_all_named_roles("g")

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

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

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

`GetPolicy()`

GetPolicy erhält alle Autorisierungsregeln in der Richtlinie.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

policy = e.GetPolicy()

const policy = await e.getPolicy()

$policy = $e->getPolicy();

policy = e.get_policy()

var policy = e.GetPolicy();

let policy = e.get_policy();

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

`GetFilteredPolicy()`

GetFilteredPolicy holt alle Autorisierungsregeln in der Richtlinie, Feldfilter können angegeben werden.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

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

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

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

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

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

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

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

`GetNamedPolicy()`

GetNamedPolicy holt alle Autorisierungsregeln in den genannten Richtlinien.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

namedPolicy := e.GetNamedPolicy("p")

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

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

named_policy = e.get_named_policy("p")

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

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

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

`GetFilteredNamedPolicy()`

GetFilteredNamedPolicy holt alle Autorisierungsregeln in den angegebenen Richtlinien, Feldfilter können angegeben werden.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

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

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

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

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

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

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

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

`GetGroupingPolicy()`

GetGroupingPolicy erhält alle Rollenvererbung Regeln in der Richtlinie.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

groupingPolicy := e.GetGroupingPolicy()

const groupingPolicy = await e.getGroupingPolicy()

$groupingPolicy = $e->getGroupingPolicy();

grouping_policy = e.get_grouping_policy()

var groupingPolicy = e.GetGroupingPolicy();

let grouping_policy = e.get_grouping_policy();

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

`GetFilteredGroupingPolicy()`

GetFilteredGroupingPolicy erhält alle Rollenvererbungsregeln in der Richtlinie, Feldfilter können angegeben werden.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

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

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

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

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

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

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

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

`GetNamedGroupingPolicy()`

GetNamedGroupingPolicy erhält alle Rollenvererbungsregeln in der Richtlinie.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

namedGroupingPolicy := e.GetNamedGroupingPolicy("g")

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

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

named_grouping_policy = e.get_named_grouping_policy("g")

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

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

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

`GetFilteredNamedGroupingPolicy()`

GetFilteredNamedGroupingPolicy holt alle Rollenvererbungsregeln in der Richtlinie.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

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

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

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

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

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

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

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

`HasPolicy()`

HasPolicy bestimmt, ob eine Autorisierungsregel existiert.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

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

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

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

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

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

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

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

`HasNamedPolicy()`

HasNamedPolicy bestimmt, ob eine benannte Autorisierungsregel existiert.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

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

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

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

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

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

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

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

`AddPolicy()`

AddPolicy fügt der aktuellen Richtlinie eine Autorisierungsregel hinzu. Wenn die Regel bereits existiert, gibt die Funktion falsch 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:

Node.js

PHP

Python

.NET

Rust

Java

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

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

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

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

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

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

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

`AddPolicies()`

AddPolicies fügt Autorisierungsregeln zu den aktuellen Richtlinien hinzu. Die Operation ist atomarer Natur. Wenn also Autorisierungsregeln aus Regeln bestehen, die nicht mit der aktuellen Politik übereinstimmen die Funktion falsch zurückgibt und keine Richtlinien-Regel zur aktuellen Richtlinie hinzugefügt wird. Wenn alle Autorisierungsregeln mit den Regeln der Politik übereinstimmen, gibt die Funktion wahr zurück und jede Richtlinien-Regel wird der aktuellen Richtlinie hinzugefügt.

Zum Beispiel:

Node.js

Python

Rust

Java

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

areRulesAdded := e.AddPolicies(rules)

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

const areRulesAdded = await e.addPolicies(rules);

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

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?

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

boolean areRulesAdded = e.addPolicies(rules);

`AddNamedPolicy()`

AddNamedPolicy fügt der aktuell benannten Richtlinie eine Autorisierungsregel hinzu. Wenn die Regel bereits existiert, gibt die Funktion falsch 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:

Node.js

PHP

Python

.NET

Rust

Java

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

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

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

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

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

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

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

`AddNamedPolicies()`

AddNamedPolicies fügt Autorisierungsregeln zu den aktuell benannten Richtlinien hinzu. Die Operation ist atomarer Natur. Wenn also Autorisierungsregeln aus Regeln bestehen, die nicht mit der aktuellen Politik übereinstimmen die Funktion falsch zurückgibt und keine Richtlinien-Regel zur aktuellen Richtlinie hinzugefügt wird. Wenn alle Autorisierungsregeln mit den Regeln der Politik übereinstimmen, gibt die Funktion wahr zurück und jede Richtlinien-Regel wird der aktuellen Richtlinie hinzugefügt.

Zum Beispiel:

Node.js

Python

Rust

Java

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

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

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

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

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

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?;

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

`RemovePolicy()`

Entfernt eine Autorisierungsregel aus der aktuellen Richtlinie.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

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

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

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

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

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

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

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

`Policies() entfernen`

Entfernen von Richtlinien entfernt Autorisierungsregeln aus der aktuellen Richtlinie. Die Operation ist atomarer Natur. Wenn also Autorisierungsregeln aus Regeln bestehen, die nicht mit der aktuellen Politik übereinstimmen die Funktion falsch zurückgibt und keine Richtlinien-Regel aus der aktuellen Richtlinie entfernt wird. Wenn alle Autorisierungsregeln mit den Regeln übereinstimmen, gibt die Funktion wahr zurück und jede Regel wird aus der aktuellen Richtlinie entfernt.

Zum Beispiel:

Node.js

Python

Rust

Java

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

areRulesRemoved := e.RemovePolicies(rules)

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

const areRulesRemoved = await e.removePolicies(rules);

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

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?;

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

`FilteredPolicy() entfernen`

Entfernen FilteredPolicy entfernt eine Autorisierungsregel aus der aktuellen Richtlinie. Feldfilter können angegeben werden. Entfernt eine Autorisierungsregel aus der aktuellen Richtlinie.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

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

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

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

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

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

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

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

`RemoveNamedPolicy()`

Entfernt eine Autorisierungsregel aus der aktuell benannten Richtlinie.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

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

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

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

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

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

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

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

`RemoveNamedPolicies()`

Entfernt die Autorisierungsregeln aus der aktuell benannten Richtlinie. Die Operation ist atomarer Natur. Wenn also Autorisierungsregeln aus Regeln bestehen, die nicht mit der aktuellen Politik übereinstimmen die Funktion falsch zurückgibt und keine Richtlinien-Regel aus der aktuellen Richtlinie entfernt wird. Wenn alle Autorisierungsregeln mit den Regeln übereinstimmen, gibt die Funktion wahr zurück und jede Regel wird aus der aktuellen Richtlinie entfernt.

Zum Beispiel:

Node.js

Python

Rust

Java

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

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

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

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

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

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?;

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

`Entfernt FilteredNamedPolicy()`

RemoveFilteredNamedPolicy entfernt eine Autorisierungsregel aus der aktuellen Richtlinie. Feldfilter können angegeben werden.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

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

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

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

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

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

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

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

`HasGroupingPolicy()`

HasGroupingPolicy bestimmt, ob eine Rollenvererbungsregel existiert.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

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

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

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

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

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

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

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

`HasNamedGroupingPolicy()`

HasNamedGroupingPolicy legt fest, ob eine benannte Rollenvererbungsregel existiert.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

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

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

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

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

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

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

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

`AddGroupingPolicy()`

AddGroupingPolicy fügt der aktuellen Richtlinie eine Rollenvererbungsregel hinzu. Wenn die Regel bereits existiert, gibt die Funktion falsch 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:

Node.js

PHP

Python

.NET

Rust

Java

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

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

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

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

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

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

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

`AddGroupingPolicies()`

AddGroupingPolicies fügt Rollenvererbungsregeln zu den aktuellen Richtlinien hinzu. Die Operation ist atomarer Natur. Wenn also Autorisierungsregeln aus Regeln bestehen, die nicht mit der aktuellen Politik übereinstimmen die Funktion falsch zurückgibt und keine Richtlinien-Regel zur aktuellen Richtlinie hinzugefügt wird. Wenn alle Autorisierungen mit den Regeln übereinstimmen, gibt die Funktion wahr zurück und jede Richtlinien-Regel wird der aktuellen Richtlinie hinzugefügt.

Zum Beispiel:

Node.js

Python

Rust

Java

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

areRulesAdded := e.AddGroupingPolicies(rules)

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

const areRulesAdded = await e.addGroupingPolicies(groupingRules);

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

are_rules_added = e.add_grouping_policies(rules)

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?;

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

`AddNamedGroupingPolicy()`

AddNamedGroupingPolicy fügt der aktuellen Richtlinie eine benannte Rollenvererbungsregel hinzu. Wenn die Regel bereits existiert, gibt die Funktion falsch 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:

Node.js

PHP

Python

.NET

Rust

Java

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

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

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

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

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

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

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

`AddNamedGroupingPolicies()`

AddNamedGroupingPolicies fügt den aktuellen Richtlinien benannte Vererbungsregeln hinzu. Die Operation ist atomarer Natur. Wenn also Autorisierungsregeln aus Regeln bestehen, die nicht mit der aktuellen Politik übereinstimmen die Funktion falsch zurückgibt und keine Richtlinien-Regel zur aktuellen Richtlinie hinzugefügt wird. Wenn alle Autorisierungsregeln mit den Regeln der Politik übereinstimmen, gibt die Funktion wahr zurück und jede Richtlinien-Regel wird der aktuellen Richtlinie hinzugefügt.

Zum Beispiel:

Node.js

Python

Rust

Java

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

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

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

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

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

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

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?;

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

`RemoveGroupingPolicy()`

RemoveGroupingPolicy entfernt eine Rollenvererbungsregel aus der aktuellen Richtlinie.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

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

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

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

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

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

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

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

`Entfernt Gruppenrichtlinien()`

Entfernen von GroupingPolicies entfernt Rollenvererbungsregeln aus der aktuellen Richtlinie. Die Operation ist atomarer Natur. Wenn also Autorisierungsregeln aus Regeln bestehen, die nicht mit der aktuellen Politik übereinstimmen die Funktion falsch zurückgibt und keine Richtlinien-Regel aus der aktuellen Richtlinie entfernt wird. Wenn alle Autorisierungsregeln mit den Regeln übereinstimmen, gibt die Funktion wahr zurück und jede Regel wird aus der aktuellen Richtlinie entfernt.

Zum Beispiel:

Node.js

Rust

Python

Java

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

areRulesRemoved := e.RemoveGroupingPolicies(rules)

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

const areRulesRemoved = await e.removeGroupingPolicies(groupingRules);

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?;

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

are_rules_removed = e.remove_grouping_policies(rules)

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

`FilteredGroupingPolicy() entfernen`

RemoveFilteredGroupingPolicy entfernt eine Rollenvererbungsregel aus der aktuellen Richtlinie. Feldfilter können angegeben werden.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

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

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

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

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

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

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

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

`RemoveNamedGroupingPolicy()`

RemoveNamedGroupingPolicy entfernt eine Rollenvererbungsregel aus der aktuell benannten Richtlinie.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

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

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

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

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

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

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

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

`RemoveNamedGroupingPolicies()`

RemoveNamedGroupingPolicies entfernt benannte Rollenvererbungsregeln aus der aktuellen Richtlinie. Die Operation ist atomarer Natur. Wenn also Autorisierungsregeln aus Regeln bestehen, die nicht mit der aktuellen Politik übereinstimmen die Funktion falsch zurückgibt und keine Richtlinien-Regel aus der aktuellen Richtlinie entfernt wird. Wenn alle Autorisierungsregeln mit den Regeln übereinstimmen, gibt die Funktion wahr zurück und jede Regel wird aus der aktuellen Richtlinie entfernt.

Zum Beispiel:

Node.js

Python

Rust

Java

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

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

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

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

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

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?;

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

`RemoveFilteredNamedGroupingPolicy()`

RemoveFilteredNamedGroupingPolicy entfernt eine Rollenvererbungsregel aus der aktuell benannten Richtlinie. Feldfilter können angegeben werden.

Zum Beispiel:

Node.js

PHP

Python

.NET

Rust

Java

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

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

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

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

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

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

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

`UpdatePolicy()`

UpdatePolicy aktualisiert eine alte Richtlinie auf neue Richtlinien.

Zum Beispiel:

Node.js

Python

Java

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

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

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

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

`UpdatePolicies()`

UpdatePolicies aktualisiert alle alten Richtlinien auf neue Richtlinien.

Zum Beispiel:

Python

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

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:

Node.js

PHP

Python

Rust

Java

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)

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

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

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)

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

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 der Datei/Datenbank.

Zum Beispiel:

Node.js

Java

Python

err := e.LoadFilteredPolicy()

const ok = await e.loadFilteredPolicy();

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

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)

`LoadIncrementalFilteredPolicy()`

LoadIncrementalFilteredPolicy fügt eine gefilterte Richtlinie aus der Datei/Datenbank hinzu.

Zum Beispiel:

Node.js

Python

err := e.LoadIncrementalFilteredPolicy()

const ok = await e.loadIncrementalFilteredPolicy();

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 alte Regeln auf newRulein g Abschnitt

Zum Beispiel:

Java

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

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

`UpdateNamedGroupingPolicy()`

UpdateNamedGroupingPolicy aktualisiert alte Regeln mit dem Namen ptype auf newRulein g Abschnitt

Zum Beispiel:

Java

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

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