Passer au contenu principal

Management API

L'API primitive qui fournit un support complet pour la gestion des politiques Casbin.

Filtered API

Presque toutes les api filtrées ont les mêmes paramètres (fieldIndex int, fieldValues ...string). fieldIndex est l'index où commence la correspondance, fieldValues désigne les valeurs que le résultat devrait avoir. Notez qu'une chaîne vide dans fieldValues pourrait être n'importe quel mot.

Exemple :

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

Référence

la variable globale e est une instance de Enforcer.

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

Enforce()

Enforce décide si un "sujet" peut accéder à un "objet" avec l'opération "action", les paramètres d'entrée sont généralement : (sub, obj, act).

Par exemple :

ok, err := e.Enforce(request)

EnforceWithMatcher()

EnforceWithMatcher utilise un comparateur personnalisé pour décider si un "sujet" peut accéder à un "objet" avec l'opération "action", les paramètres d'entrée sont généralement : (matcher, sub, obj, act), utilise le comparateur de modèle par défaut lorsque matcher est "".

Par exemple :

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

EnforceEx()

EnforceEx explique l'application en informant les règles correspondantes.

Par exemple :

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

EnforceExWithMatcher()

EnforceExWithMatcher utilise un comparateur personnalisé et explique l'application en informant les règles correspondantes.

Par exemple :

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

BatchEnforce()

BatchEnforce applique chaque requête et renvoie le résultat dans un tableau booléen

Par exemple :

boolArray, err := e.BatchEnforce(requests)

GetAllSubjects()

GetAllSubjects obtient la liste des sujets qui apparaissent dans la politique actuelle.

Par exemple :

allSubjects := e.GetAllSubjects()

GetAllNamedSubjects()

GetAllNamedSubjects obtient la liste des sujets qui apparaissent dans la politique nommée actuelle.

Par exemple :

allNamedSubjects := e.GetAllNamedSubjects("p")

GetAllObjects()

GetAllObjects obtient la liste des objets qui apparaissent dans la politique actuelle.

Par exemple :

allObjects := e.GetAllObjects()

GetAllNamedObjects()

GetAllNamedObjects obtient la liste des objets qui apparaissent dans la politique nommée actuelle.

Par exemple :

allNamedObjects := e.GetAllNamedObjects("p")

GetAllActions()

GetAllActions obtient la liste des actions qui apparaissent dans la politique actuelle.

Par exemple :

allActions := e.GetAllActions()

GetAllNamedActions()

GetAllNamedActions obtient la liste des actions qui apparaissent dans la politique nommée actuelle.

Par exemple :

allNamedActions := e.GetAllNamedActions("p")

GetAllRoles()

GetAllRoles obtient la liste des rôles qui apparaissent dans la politique actuelle.

Par exemple:

allRoles = e.GetAllRoles()

GetAllNamedRoles()

GetAllNamedRoles obtient la liste des rôles qui apparaissent dans la politique nommée actuelle.

Par exemple:

allNamedRoles := e.GetAllNamedRoles("g")

GetPolicy()

GetPolicy obtient toutes les règles d'autorisation dans la politique.

Par exemple:

policy = e.GetPolicy()

GetFilteredPolicy()

GetFilteredPolicy obtient toutes les règles d'autorisation dans la politique, des filtres de champ peuvent être spécifiés.

Par exemple:

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

GetNamedPolicy()

GetNamedPolicy obtient toutes les règles d'autorisation dans la politique nommée.

Par exemple:

namedPolicy := e.GetNamedPolicy("p")

GetFilteredNamedPolicy()

GetFilteredNamedPolicy obtient toutes les règles d'autorisation dans la politique nommée, des filtres de champ peuvent être spécifiés.

Par exemple:

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

GetGroupingPolicy()

GetGroupingPolicy obtient toutes les règles d'héritage de rôle dans la politique.

Par exemple:

groupingPolicy := e.GetGroupingPolicy()

GetFilteredGroupingPolicy()

GetFilteredGroupingPolicy obtient toutes les règles d'héritage de rôle dans la politique, des filtres de champ peuvent être spécifiés.

Par exemple:

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

GetNamedGroupingPolicy()

GetNamedGroupingPolicy obtient toutes les règles d'héritage de rôle dans la politique.

Par exemple:

namedGroupingPolicy := e.GetNamedGroupingPolicy("g")

GetFilteredNamedGroupingPolicy()

GetFilteredNamedGroupingPolicy obtient toutes les règles d'héritage de rôle dans la politique.

Par exemple:

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

HasPolicy()

HasPolicy détermine si une règle d'autorisation existe.

Par exemple:

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

HasNamedPolicy()

HasNamedPolicy détermine si une règle d'autorisation nommée existe.

Par exemple:

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

AddPolicy()

AddPolicy ajoute une règle d'autorisation à la politique actuelle. Si la règle existe déjà, la fonction renvoie false et la règle ne sera pas ajoutée. Sinon, la fonction renvoie true en ajoutant la nouvelle règle.

Par exemple:

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

AddPolicies()

AddPolicies ajoute des règles d'autorisation à la politique actuelle. L'opération est de nature atomique. Par conséquent, si les règles d'autorisation consistent en des règles qui ne sont pas cohérentes avec la politique actuelle, la fonction renvoie false et aucune règle de politique n'est ajoutée à la politique actuelle. Si toutes les règles d'autorisation sont cohérentes avec les règles de politique, la fonction renvoie true et chaque règle de politique est ajoutée à la politique actuelle.

Par exemple :

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

areRulesAdded := e.AddPolicies(rules)

AddPoliciesEx()

AddPoliciesEx ajoute des règles d'autorisation à la politique actuelle. Si la règle existe déjà, la règle ne sera pas ajoutée. Mais contrairement à AddPolicies, d'autres règles non existantes sont ajoutées au lieu de renvoyer false directement

Par exemple :

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

AddNamedPolicy()

AddNamedPolicy ajoute une règle d'autorisation à la politique nommée actuelle. Si la règle existe déjà, la fonction renvoie false et la règle ne sera pas ajoutée. Sinon, la fonction renvoie true en ajoutant la nouvelle règle.

Par exemple :

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

AddNamedPolicies()

AddNamedPolicies ajoute des règles d'autorisation à la politique nommée actuelle. L'opération est atomique de nature. Par conséquent, si les règles d'autorisation consistent en des règles qui ne sont pas cohérentes avec la politique actuelle, la fonction renvoie false et aucune règle de politique n'est ajoutée à la politique actuelle. Si toutes les règles d'autorisation sont cohérentes avec les règles de politique, la fonction renvoie true et chaque règle de politique est ajoutée à la politique actuelle.

Par exemple :

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

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

AddNamedPoliciesEx()

AddNamedPoliciesEx ajoute des règles d'autorisation à la politique nommée actuelle. Si la règle existe déjà, la règle ne sera pas ajoutée. Mais contrairement à AddNamedPolicies, d'autres règles non existantes sont ajoutées au lieu de renvoyer false directement

Par exemple :

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

SelfAddPoliciesEx()

SelfAddPoliciesEx ajoute des règles d'autorisation à la politique nommée actuelle avec autoNotifyWatcher désactivé. Si la règle existe déjà, la règle ne sera pas ajoutée. Mais contrairement à SelfAddPolicies, d'autres règles non existantes sont ajoutées au lieu de renvoyer false directement

Par exemple :

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

RemovePolicy()

RemovePolicy supprime une règle d'autorisation de la politique actuelle.

Par exemple :

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

RemovePolicies()

RemovePolicies supprime des règles d'autorisation de la politique actuelle. L'opération est atomique de nature. Par conséquent, si les règles d'autorisation consistent en des règles qui ne sont pas cohérentes avec la politique actuelle, la fonction renvoie false et aucune règle de politique n'est supprimée de la politique actuelle. Si toutes les règles d'autorisation sont cohérentes avec les règles de politique, la fonction renvoie vrai et chaque règle de politique est retirée de la politique actuelle.

Par exemple :

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

areRulesRemoved := e.RemovePolicies(rules)

RemoveFilteredPolicy()

RemoveFilteredPolicy supprime une règle d'autorisation de la politique actuelle, des filtres de champ peuvent être spécifiés. RemovePolicy supprime une règle d'autorisation de la politique actuelle.

Par exemple :

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

RemoveNamedPolicy()

RemoveNamedPolicy supprime une règle d'autorisation de la politique nommée actuelle.

Par exemple :

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

RemoveNamedPolicies()

RemoveNamedPolicies supprime des règles d'autorisation de la politique nommée actuelle. L'opération est de nature atomique. Par conséquent, si les règles d'autorisation consistent en des règles qui ne sont pas cohérentes avec la politique actuelle, la fonction renvoie faux et aucune règle de politique n'est retirée de la politique actuelle. Si toutes les règles d'autorisation sont cohérentes avec les règles de politique, la fonction renvoie vrai et chaque règle de politique est retirée de la politique actuelle.

Par exemple :

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

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

RemoveFilteredNamedPolicy()

RemoveFilteredNamedPolicy supprime une règle d'autorisation de la politique nommée actuelle, des filtres de champ peuvent être spécifiés.

Par exemple :

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

HasGroupingPolicy()

HasGroupingPolicy détermine si une règle d'héritage de rôle existe.

Par exemple :

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

HasNamedGroupingPolicy()

HasNamedGroupingPolicy détermine si une règle d'héritage de rôle nommée existe.

Par exemple :

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

AddGroupingPolicy()

AddGroupingPolicy ajoute une règle d'héritage de rôle à la politique actuelle. Si la règle existe déjà, la fonction renvoie faux et la règle ne sera pas ajoutée. Sinon, la fonction renvoie vrai en ajoutant la nouvelle règle.

Par exemple :

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

AddGroupingPolicies()

AddGroupingPolicies ajoute des règles d'héritage de rôle à la politique actuelle. L'opération est de nature atomique. Par conséquent, si les règles d'autorisation consistent en des règles qui ne sont pas cohérentes avec la politique actuelle, la fonction renvoie faux et aucune règle de politique n'est ajoutée à la politique actuelle. Si toutes les règles d'autorisation sont cohérentes avec les règles de politique, la fonction renvoie vrai et chaque règle de politique est ajoutée à la politique actuelle.

Par exemple :

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

areRulesAdded := e.AddGroupingPolicies(rules)

AddGroupingPoliciesEx()

AddGroupingPoliciesEx ajoute des règles d'héritage de rôle à la politique actuelle. Si la règle existe déjà, la règle ne sera pas ajoutée. Mais contrairement à AddGroupingPolicies, d'autres règles non existantes sont ajoutées au lieu de renvoyer directement faux

Par exemple:

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

AddNamedGroupingPolicy()

AddNamedGroupingPolicy ajoute une règle d'héritage de rôle nommée à la politique actuelle. Si la règle existe déjà, la fonction renvoie false et la règle ne sera pas ajoutée. Sinon, la fonction renvoie true en ajoutant la nouvelle règle.

Par exemple:

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

AddNamedGroupingPolicies()

AddNamedGroupingPolicies ajoute des règles d'héritage de rôle nommées à la politique actuelle. L'opération est de nature atomique. Par conséquent, si les règles d'autorisation se composent de règles qui ne sont pas cohérentes avec la politique actuelle, la fonction renvoie false et aucune règle de politique n'est ajoutée à la politique actuelle. Si toutes les règles d'autorisation sont cohérentes avec les règles de politique, la fonction renvoie true et chaque règle de politique est ajoutée à la politique actuelle.

Par exemple:

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

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

AddNamedGroupingPoliciesEx()

AddNamedGroupingPoliciesEx ajoute des règles d'héritage de rôle nommées à la politique actuelle. Si la règle existe déjà, la règle ne sera pas ajoutée. Mais contrairement à AddNamedGroupingPolicies, d'autres règles non existantes sont ajoutées au lieu de renvoyer false directement

Par exemple:

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

RemoveGroupingPolicy()

RemoveGroupingPolicy supprime une règle d'héritage de rôle de la politique actuelle.

Par exemple:

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

RemoveGroupingPolicies()

RemoveGroupingPolicies supprime des règles d'héritage de rôle de la politique actuelle. L'opération est de nature atomique. Par conséquent, si les règles d'autorisation se composent de règles qui ne sont pas cohérentes avec la politique actuelle, la fonction renvoie false et aucune règle de politique n'est supprimée de la politique actuelle. Si toutes les règles d'autorisation sont cohérentes avec les règles de politique, la fonction renvoie true et chaque règle de politique est supprimée de la politique actuelle.

Par exemple:

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

areRulesRemoved := e.RemoveGroupingPolicies(rules)

RemoveFilteredGroupingPolicy()

RemoveFilteredGroupingPolicy supprime une règle d'héritage de rôle de la politique actuelle, des filtres de champ peuvent être spécifiés.

Par exemple:

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

RemoveNamedGroupingPolicy()

RemoveNamedGroupingPolicy supprime une règle d'héritage de rôle de la politique nommée actuelle.

Par exemple:

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

RemoveNamedGroupingPolicies()

RemoveNamedGroupingPolicies supprime des règles d'héritage de rôle nommées de la politique actuelle. L'opération est de nature atomique. Par conséquent, si les règles d'autorisation se composent de règles qui ne sont pas cohérentes avec la politique actuelle, la fonction renvoie false et aucune règle de politique n'est supprimée de la politique actuelle. Si toutes les règles d'autorisation sont cohérentes avec les règles de politique, la fonction renvoie true et chaque règle de politique est supprimée de la politique actuelle.

Par exemple:

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

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

RemoveFilteredNamedGroupingPolicy()

RemoveFilteredNamedGroupingPolicy supprime une règle d'héritage de rôle de la politique nommée actuelle, des filtres de champ peuvent être spécifiés.

Par exemple:

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

UpdatePolicy()

UpdatePolicy met à jour une ancienne politique en une nouvelle politique.

Par exemple:

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

UpdatePolicies()

UpdatePolicies met à jour toutes les anciennes politiques en nouvelles politiques.

Par exemple:

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

AddFunction()

AddFunction ajoute une fonction personnalisée.

Par exemple:

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)

LoadFilteredPolicy()

LoadFilteredPolicy charge des politiques filtrées à partir du fichier/de la base de données.

Par exemple:

err := e.LoadFilteredPolicy()

LoadIncrementalFilteredPolicy()

LoadIncrementalFilteredPolicy ajoute une politique filtrée à partir du fichier/de la base de données.

Par exemple:

err := e.LoadIncrementalFilteredPolicy()

UpdateGroupingPolicy()

UpdateGroupingPolicy met à jour oldRule en newRulein dans la section g

Par exemple:

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

UpdateNamedGroupingPolicy()

UpdateNamedGroupingPolicy met à jour oldRule nommé ptype en newRulein dans la section g

Par exemple:

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

SetFieldIndex()

SetFieldIndex supporte la personnalisation du nom conventionnel et de la position de sub, obj, domain et priority.

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

Par exemple:

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