管理API

提供对Casbin策略管理完全支持的基本API。

参考

全局变量 e是执行者实例。

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

GetAllSubjects()

GetAllSubjects 获取当前策略中显示的主题列表。
For example:

allSubjects := e.GetAllSubjects()

GetAllNamedSubjects()

GetAllNamedSubjects 获取当前命名策略中显示的主题列表。
For example:

allNamedSubjects := e.GetAllNamedSubjects("p")

GetAllObjects()

GetAllObjects 获取当前策略中显示的对象列表。
例如：

allObjects := e.GetAllObjects()

GetAllNamedObjects()

GetAllNamedObjects 获取当前命名策略中显示的对象列表。
例如：

allNamedObjects := e.GetAllNamedObjects("p")

GetAllActions()

GetAllActions 获取当前策略中显示的操作列表。
例如：

allActions := e.GetAllActions()

GetAllNamedActions()

GetAllNamedActions 获取当前命名策略中显示的操作列表。
例如：

allNamedActions := e.GetAllNamedActions("p")

GetAllRoles()

GetAllRoles获取当前策略中显示的角色列表。
例如：

allRoles = e.GetAllRoles()

GetAllNamedRoles()

GetAllNamedRoles 获取当前命名策略中显示的角色列表。
例如：

allNamedRoles := e.GetAllNamedRoles("g")

GetPolicy()

GetPolicy 获取策略中的所有授权规则。
例如：

policy = e.GetPolicy()

GetFilteredPolicy()

GetFilteredPolicy 获取策略中的所有授权规则，可以指定字段筛选器。
例如：

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

GetNamedPolicy()

GetNamedPolicy 获取命名策略中的所有授权规则。
例如：

namedPolicy := e.GetNamedPolicy("p")

GetFilteredNamedPolicy()

GetFilteredNamedPolicy 获取命名策略中的所有授权规则，可以指定字段过滤器。
例如：

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

GetGroupingPolicy()

GetGroupingPolicy 获取策略中的所有角色继承规则。
例如：

groupingPolicy := e.GetGroupingPolicy()

GetFilteredGroupingPolicy()

GetFilteredGroupingPolicy 获取策略中的所有角色继承规则，可以指定字段筛选器。
例如：

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

GetFilteredNamedGroupingPolicy()

GetFilteredNamedGroupingPolicy 获取策略中的所有角色继承规则。
例如：

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

HasPolicy()

HasPolicy 确定是否存在授权规则。
例如：

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

HasNamedPolicy()

HasNamedPolicy 确定是否存在命名授权规则。
例如：

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

AddPolicy()

AddPolicy 向当前策略添加授权规则。 如果规则已经存在，函数返回false，并且不会添加规则。 否则，函数通过添加新规则并返回true。
例如：

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

AddPolicies()

AddPolicies向当前策略添加授权规则。这种操作本质上是原子性的。因此，如果授权规则由与当前策略不一致的规则组成，则函数返回false，并且不向当前策略添加任何策略规则。如果所有授权规则与策略规则一致，则函数返回true，并将每个策略规则添加到当前策略中。
例如：

rules := [][] string {
                []string {"jack", "data4", "read"},
                []string {"katy", "data4", "write"},
                []string {"leyo", "data4", "read"},
                []string {"ham", "data4", "write"},
        }
areRulesAdded := e.AddPolicies(rules)

AddNamedPolicy()

AddNamedPolicy将授权规则添加到当前命名策略。如果规则已经存在，函数将返回false，并且规则将不被添加。否则，函数将通过添加新规则返回true。
例如：

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

AddNamedPolicies()

AddNamedPolicies向当前命名策略添加授权规则。这种操作本质上是原子性的。因此，如果授权规则由与当前策略不一致的规则组成，则函数返回false，并且不向当前策略添加任何策略规则。如果所有授权规则与策略规则一致，则函数返回true，并将每个策略规则添加到当前策略中。
例如：

rules := [][] string {
                []string {"jack", "data4", "read"},
                []string {"katy", "data4", "write"},
                []string {"leyo", "data4", "read"},
                []string {"ham", "data4", "write"},
        }
areRulesAdded := e.AddNamedPolicies("p", rules)

RemovePolicy()

RemovePolicy从当前策略中删除授权规则。
例如：

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

RemovePolicies()

RemovePolicies从当前策略中删除授权规则。这种操作本质上是原子性的。因此，如果授权规则由与当前策略不一致的规则组成，函数将返回false，并且没有策略规则从当前策略中删除。如果所有授权规则都与策略规则一致，则函数返回true，并且从当前策略中删除每个策略规则。
例如：

rules := [][] string {
                []string {"jack", "data4", "read"},
                []string {"katy", "data4", "write"},
                []string {"leyo", "data4", "read"},
                []string {"ham", "data4", "write"},
        }
areRulesRemoved := e.RemovePolicies(rules)

RemoveFilteredPolicy()

RemoveFilteredPolicy从当前策略中删除授权规则，可以指定字段筛选器。RemovePolicy从当前策略中删除授权规则。
例如：

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

RemoveNamedPolicy()

RemoveNamedPolicy从当前命名策略中删除授权规则。

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

RemoveNamedPolicies()

RemoveNamedPolicies从当前命名策略中删除授权规则。这种操作本质上是原子性的。因此，如果授权规则由与当前策略不一致的规则组成，函数将返回false，并且没有策略规则从当前策略中删除。如果所有授权规则都与策略规则一致，则函数返回true，并且从当前策略中删除每个策略规则。
例如：

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从当前命名策略中删除授权规则，可以指定字段筛选器。
例如：

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

HasGroupingPolicy()

HasGroupingPolicy确定角色继承规则是否存在。
例如：

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

HasNamedGroupingPolicy()

HasNamedGroupingPolicy确定是否存在命名角色继承规则。
例如：

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

AddGroupingPolicy()

AddGroupingPolicy将角色继承规则添加到当前策略。如果规则已经存在，函数将返回false，并且规则将不被添加。否则，函数将通过添加新规则返回true。
例如：

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

AddGroupingPolicies()

AddGroupingPolicies将角色继承规则添加到当前策略中。这种操作本质上是原子性的。因此，如果授权规则由与当前策略不一致的规则组成，则函数返回false，并且不向当前策略添加任何策略规则。如果所有授权规则与策略规则一致，则函数返回true，并将每个策略规则添加到当前策略中。
例如：

rules := [][] string {
                []string {"jack", "data4", "read"},
                []string {"katy", "data4", "write"},
                []string {"leyo", "data4", "read"},
                []string {"ham", "data4", "write"},
        }
areRulesAdded := e.AddGroupingPolicies(rules)

AddNamedGroupingPolicy()

AddNamedGroupingPolicy将命名角色继承规则添加到当前策略。如果规则已经存在，函数将返回false，并且规则将不被添加。否则，函数将通过添加新规则返回true。
例如：

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

AddNamedGroupingPolicies()

AddNamedGroupingPolicies将命名角色继承规则添加到当前策略中。这种操作本质上是原子性的。因此，如果授权规则由与当前策略不一致的规则组成，则函数返回false，并且不向当前策略添加任何策略规则。如果所有授权规则与策略规则一致，则函数返回true，并将每个策略规则添加到当前策略中。
For example:

rules := [][] string {
                []string {"jack", "data4", "read"},
                []string {"katy", "data4", "write"},
                []string {"leyo", "data4", "read"},
                []string {"ham", "data4", "write"},
        }
areRulesAdded := e.AddNamedGroupingPolicies("g", rules)

RemoveGroupingPolicy()

RemoveGroupingPolicy从当前策略删除角色继承规则。
For example:

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

RemoveGroupingPolicies()

RemoveGroupingPolicies从当前策略中删除角色继承规则。这种操作本质上是原子性的。因此，如果授权规则由与当前策略不一致的规则组成，函数将返回false，并且没有策略规则从当前策略中删除。如果所有授权规则都与策略规则一致，则函数返回true，并且从当前策略中删除每个策略规则。
For example:

rules := [][] string {
                []string {"jack", "data4", "read"},
                []string {"katy", "data4", "write"},
                []string {"leyo", "data4", "read"},
                []string {"ham", "data4", "write"},
        }
areRulesRemoved := e.RemoveGroupingPolicies(rules)

RemoveFilteredGroupingPolicy()

RemoveFilteredGroupingPolicy从当前策略中删除角色继承规则，可以指定字段过滤器。
For example:

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

RemoveNamedGroupingPolicy()

RemoveNamedGroupingPolicy从当前命名策略中删除角色继承规则。
For example:

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

RemoveNamedGroupingPolicies()

RemoveNamedGroupingPolicies从当前策略中删除指定角色继承规则。这种操作本质上是原子性的。因此，如果授权规则由与当前策略不一致的规则组成，函数将返回false，并且没有策略规则从当前策略中删除。如果所有授权规则都与策略规则一致，则函数返回true，并且从当前策略中删除每个策略规则。

rules := [][] string {
                []string {"jack", "data4", "read"},
                []string {"katy", "data4", "write"},
                []string {"leyo", "data4", "read"},
                []string {"ham", "data4", "write"},
        }
areRulesRemoved := e.RemoveNamedGroupingPolicies("g", rules)

RemoveFilteredNamedGroupingPolicy()

RemoveFilteredNamedGroupingPolicy从当前命名策略中删除角色继承规则，可以指定字段过滤器。
For example:

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

UpdatePolicy()

更新旧策略为新策略。
For example:

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

AddFunction()

添加一个自定义函数。
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)