Passer au contenu principal

API de gestion

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

API filtr√©e‚Äč

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 indique les valeurs r√©sultat doivent avoir. Notez que la cha√ģne vide dans les valeurs du champ peut √™tre n'importe quel mot.

Exemple:

p, alice, livre, lire
p, bob, livre, lire
p, bob, livre, écrire
p, alice, stylo, get
p, bob, stylo ,get
e.GetFilteredPolicy(1, "book") // retournera : [[alice book read] [bob book read] [bob book write]]

e. etFilteredPolicy(1, "book", "read") // retournera : [[alice book read] [bob book read]]

e. etFilteredPolicy(0, "alice", "", "read") // retournera : [[alice book read]]

e.GetFilteredPolicy(0, "alice") // retournera : [[alice book read] [alice pen get]]

R√©f√©rence‚Äč

la variable globale e est l'instance 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 matcher 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), utiliser le modèle de correspondance par défaut lorsque le 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 matcher personnalisé et explique l'application en informant les règles correspondantes.

Par exemple :

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

BatchEnforce()‚Äč

BatchEnforce exécute chaque requête et renvoie un tableau bool

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 récupère la liste des sujets qui apparaissent dans la politique actuelle nommée.

Par exemple :

allNamedSubjects := e.GetAllNamedSubjects("p")

GetAllObjects()‚Äč

GetAllObjects récupère la liste des objets qui apparaissent dans la politique actuelle.

Par exemple :

allObjects := e.GetAllObjects()

GetAllNamedObjects()‚Äč

GetAllNamedObjects récupère la liste des objets qui apparaissent dans la politique actuelle nommée.

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 s'affichent dans la politique actuelle nommée.

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 actuelle nomm√©e.

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 récupère toutes les règles d'autorisation dans la politique, les filtres de champs peuvent être spécifiés.

Par exemple :

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

GetNamedPolicy()‚Äč

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

Par exemple :

namedPolicy := e.GetNamedPolicy("p")

GetFilteredNamedPolicy()‚Äč

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

Par exemple :

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

GetGroupingPolicy()‚Äč

GetGroupingPolicy r√©cup√®re toutes les r√®gles d'h√©ritage de r√īle dans la politique.

Par exemple :

groupingPolicy := e.GetGroupingPolicy()

GetFilteredGroupingPolicy()‚Äč

GetFilteredGroupingPolicy r√©cup√®re toutes les r√®gles d'h√©ritage de r√īle dans la politique, les filtres de champs peuvent √™tre sp√©cifi√©s.

Par exemple :

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

GetNamedGroupingPolicy()‚Äč

GetNamedGroupingPolicy r√©cup√®re toutes les r√®gles d'h√©ritage de r√īle dans la politique.

Par exemple :

namedGroupingPolicy := e.GetNamedGroupingPolicy("g")

GetFilteredNamedGroupingPolicy()‚Äč

GetFilteredNamedGroupingPolicy r√©cup√®re 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 retourne false et la règle ne sera pas ajoutée. Sinon, la fonction retourne 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 se composent de règles qui ne sont pas compatibles avec la politique actuelle, la fonction retourne false et aucune règle de régulation n'est ajoutée à la police courante. Si toutes les règles d'autorisation sont conformes aux règles de la police, la fonction renvoie la vraie 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 adds authorization rules to the current policy. If the rule already exists, the rule will not be added. But unlike AddPolicies, other non-existent rules are added instead of returning false directly

Par exemple :

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

AddNamedPolicy()‚Äč

AddNamedPolicy ajoute une règle d'autorisation à la politique courante. Si la règle existe déjà, la fonction retourne false et la règle ne sera pas ajoutée. Sinon, la fonction retourne 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 courante. 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 compatibles avec la politique actuelle, la fonction retourne false et aucune règle de régulation n'est ajoutée à la police courante. Si toutes les règles d'autorisation sont conformes aux règles de la police, la fonction renvoie la vraie 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 adds authorization rules to the current named policy. If the rule already exists, the rule will not be added. But unlike AddNamedPolicies, other non-existent rules are added instead of returning false directly

Par exemple :

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

SelfAddPoliciesEx()‚Äč

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

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 les règles d'autorisation 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 compatibles avec la politique actuelle, la fonction retourne false et aucune règle de régulation n'est retirée de la charte courante. Si toutes les règles d'autorisation sont conformes aux règles de la police, la fonction renvoie la vraie 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, les filtres de champs 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 charte nommée courante.

Par exemple :

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

RemoveNamedPolicies()‚Äč

RemoveNamedPolicy supprime les règles d'autorisation de la politique actuelle nommée. 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 compatibles avec la politique actuelle, la fonction retourne false et aucune règle de régulation n'est retirée de la charte courante. Si toutes les règles d'autorisation sont conformes aux règles de la police, la fonction renvoie la vraie 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 charte nommée, les filtres de champs 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 retourne false et la r√®gle ne sera pas ajout√©e. Sinon, la fonction retourne true 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 se composent de r√®gles qui ne sont pas compatibles avec la politique actuelle, la fonction retourne false et aucune r√®gle de r√©gulation n'est ajout√©e √† la police courante. Si toutes les autorisations sont conformes aux r√®gles de la police, la fonction renvoie vraie, 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 adds role inheritance rules to the current policy. If the rule already exists, the rule will not be added. But unlike AddGroupingPolicies, other non-existent rules are added instead of returning false directly

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 retourne false et la r√®gle ne sera pas ajout√©e. Sinon, la fonction retourne 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 compatibles avec la politique actuelle, la fonction retourne false et aucune r√®gle de r√©gulation n'est ajout√©e √† la police courante. Si toutes les r√®gles d'autorisation sont conformes aux r√®gles de la police, la fonction renvoie la vraie 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 adds named role inheritance rules to the current policy. If the rule already exists, the rule will not be added. But unlike AddNamedGroupingPolicies, other non-existent rules are added instead of returning false directly

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 les 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 compatibles avec la politique actuelle, la fonction retourne false et aucune r√®gle de r√©gulation n'est retir√©e de la charte courante. Si toutes les r√®gles d'autorisation sont conformes aux r√®gles de la police, la fonction renvoie la vraie et chaque r√®gle de politique est retir√©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 r√®gle actuelle, les filtres de champs 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 les 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 compatibles avec la politique actuelle, la fonction retourne false et aucune r√®gle de r√©gulation n'est retir√©e de la charte courante. Si toutes les r√®gles d'autorisation sont conformes aux r√®gles de la police, la fonction renvoie la vraie et chaque r√®gle de politique est retir√©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, les filtres de champs peuvent √™tre sp√©cifi√©s.

Par exemple :

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

UpdatePolicy()‚Äč

Mettre à jour une ancienne politique vers une nouvelle politique.

Par exemple :

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

UpdatePolicies()‚Äč

Mise à jour des politiques met à jour toutes les anciennes politiques vers de 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.

For example:

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 les règles filtrées à partir de fichier/base de données.

For example:

err := e.LoadFilteredPolicy()

LoadIncrementalFilteredPolicy()‚Äč

LoadIncrementalFilteredPolicy ajoute une charte filtrée à partir de fichier/base de données.

For example:

err := e.LoadIncrementalFilteredPolicy()

UpdateGroupingPolicy()‚Äč

UpdateGroupingPolicy met à jour l'ancienne règle vers la nouvelle section g

For example:

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

UpdateNamedGroupingPolicy()‚Äč

UpdateNamedGroupingPolicy met à jour l'ancienne règle nommée ptype à la section newRulein g

For example:

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

SetFieldIndex()‚Äč

SetFieldIndex suport customization of conventional name and position of sub, obj, domain and priority.

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

For example:

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