2164857532

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/casbin/pycasbin/commit/<a class=hub.com/casbin/pycasbin/commit/<a class="double-link" href="https://git"><a class=hub.com/casbin/pycasbin/commit/<a class="double-link" href="https://git"><a class=hub.com/casbin/pycasbin/commit/<a class="double-link" href="https://git"><a class=hub.com/casbin/pycasbin/commit/53518a42ebeaef3c0c45001f9f325d59d640a8c7">53518a42e">&lt;a href=&quot;https://github.com/casbin/pycasbin/commit/</a><a class="double-link" href="https://github.com/casbin/pycasbin/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/casbin/pycasbin/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/casbin/pycasbin/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/casbin/pycasbin/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/casbin/pycasbin/commit/53518a42ebeaef3c0c45001f9f325d59d640a8c7">53518a42e</a><a href="https://github.com/casbin/pycasbin/commit/53518a42ebeaef3c0c45001f9f325d59d640a8c7">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/casbin/pycasbin/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/casbin/pycasbin/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/casbin/pycasbin/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/casbin/pycasbin/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/casbin/pycasbin/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/casbin/pycasbin/commit/53518a42ebeaef3c0c45001f9f325d59d640a8c7&quot;&gt;53518a42e&lt;/a&gt;&lt;a href=&quot;https://github.com/casbin/pycasbin/commit/53518a42ebeaef3c0c45001f9f325d59d640a8c7&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/casbin/pycasbin/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/casbin/pycasbin/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&am... (continued)

Pull Request Pull Request #249: feat: update_filtered_policies

Run Details

4 of 22 new or added lines in 3 files covered. (18.18%)

1849 of 2181 relevant lines covered (84.78%)

10.17 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

81.88

/casbin/management_enforcer.py

# Copyright 2021 The casbin Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from casbin.internal_enforcer import InternalEnforcer
from casbin.model.policy_op import PolicyOp


class ManagementEnforcer(InternalEnforcer):
    """
    ManagementEnforcer = InternalEnforcer + Management API.
    """

    def get_all_subjects(self):
        """gets the list of subjects that show up in the current policy."""
        return self.get_all_named_subjects("p")

    def get_all_named_subjects(self, ptype):
        """gets the list of subjects that show up in the current named policy."""
        return self.model.get_values_for_field_in_policy("p", ptype, 0)

    def get_all_objects(self):
        """gets the list of objects that show up in the current policy."""
        return self.get_all_named_objects("p")

    def get_all_named_objects(self, ptype):
        """gets the list of objects that show up in the current named policy."""
        return self.model.get_values_for_field_in_policy("p", ptype, 1)

    def get_all_actions(self):
        """gets the list of actions that show up in the current policy."""
        return self.get_all_named_actions("p")

    def get_all_named_actions(self, ptype):
        """gets the list of actions that show up in the current named policy."""
        return self.model.get_values_for_field_in_policy("p", ptype, 2)

    def get_all_roles(self):
        """gets the list of roles that show up in the current named policy."""
        return self.get_all_named_roles("g")

    def get_all_named_roles(self, ptype):
        """gets all the authorization rules in the policy."""
        return self.model.get_values_for_field_in_policy("g", ptype, 1)

    def get_policy(self):
        """gets all the authorization rules in the policy."""
        return self.get_named_policy("p")

    def get_filtered_policy(self, field_index, *field_values):
        """gets all the authorization rules in the policy, field filters can be specified."""
        return self.get_filtered_named_policy("p", field_index, *field_values)

    def get_named_policy(self, ptype):
        """gets all the authorization rules in the named policy."""
        return self.model.get_policy("p", ptype)

    def get_filtered_named_policy(self, ptype, field_index, *field_values):
        """gets all the authorization rules in the named policy, field filters can be specified."""
        return self.model.get_filtered_policy("p", ptype, field_index, *field_values)

    def get_grouping_policy(self):
        """gets all the role inheritance rules in the policy."""
        return self.get_named_grouping_policy("g")

    def get_filtered_grouping_policy(self, field_index, *field_values):
        """gets all the role inheritance rules in the policy, field filters can be specified."""
        return self.get_filtered_named_grouping_policy("g", field_index, *field_values)

    def get_named_grouping_policy(self, ptype):
        """gets all the role inheritance rules in the policy."""
        return self.model.get_policy("g", ptype)

    def get_filtered_named_grouping_policy(self, ptype, field_index, *field_values):
        """gets all the role inheritance rules in the policy, field filters can be specified."""
        return self.model.get_filtered_policy("g", ptype, field_index, *field_values)

    def has_policy(self, *params):
        """determines whether an authorization rule exists."""
        return self.has_named_policy("p", *params)

    def has_named_policy(self, ptype, *params):
        """determines whether a named authorization rule exists."""
        if len(params) == 1 and isinstance(params[0], list):
            str_slice = params[0]
            return self.model.has_policy("p", ptype, str_slice)

        return self.model.has_policy("p", ptype, list(params))

    def add_policy(self, *params):
        """adds an authorization rule to the current policy.

        If the rule already exists, the function returns false and the rule will not be added.
        Otherwise the function returns true by adding the new rule.
        """
        return self.add_named_policy("p", *params)

    def add_policies(self, rules):
        """adds authorization rules to the current policy.

        If the rule already exists, the function returns false for the corresponding rule and the rule will not be added.
        Otherwise the function returns true for the corresponding rule by adding the new rule.
        """
        return self.add_named_policies("p", rules)

    def add_named_policy(self, ptype, *params):
        """adds an authorization rule to the current named policy.

        If the rule already exists, the function returns false and the rule will not be added.
        Otherwise the function returns true by adding the new rule.
        """

        if len(params) == 1 and isinstance(params[0], list):
            str_slice = params[0]
            rule_added = self._add_policy("p", ptype, str_slice)
        else:
            rule_added = self._add_policy("p", ptype, list(params))

        return rule_added

    def add_named_policies(self, ptype, rules):
        """adds authorization rules to the current named policy.

        If the rule already exists, the function returns false for the corresponding rule and the rule will not be added.
        Otherwise the function returns true for the corresponding by adding the new rule."""
        return self._add_policies("p", ptype, rules)

    def update_policy(self, old_rule, new_rule):
        """updates an authorization rule from the current policy."""
        return self.update_named_policy("p", old_rule, new_rule)

    def update_policies(self, old_rules, new_rules):
        """updates authorization rules from the current policy."""
        return self.update_named_policies("p", old_rules, new_rules)

    def update_named_policy(self, ptype, old_rule, new_rule):
        """updates an authorization rule from the current named policy."""
        return self._update_policy("p", ptype, old_rule, new_rule)

    def update_named_policies(self, ptype, old_rules, new_rules):
        """updates authorization rules from the current named policy."""
        return self._update_policies("p", ptype, old_rules, new_rules)

    def update_filtered_policies(self, new_rules, field_index, *field_values):
        """update_filtered_policies deletes old rules and adds new rules."""
        return self.update_filtered_named_policies(
            "p", new_rules, field_index, *field_values
        )

    def update_filtered_named_policies(
        self, ptype, new_rules, field_index, *field_values
    ):
        """update_filtered_named_policies deletes old rules and adds new rules."""
        return self._update_filtered_policies(
            "p", ptype, new_rules, field_index, *field_values
        )

    def remove_policy(self, *params):
        """removes an authorization rule from the current policy."""
        return self.remove_named_policy("p", *params)

    def remove_policies(self, rules):
        """removes authorization rules from the current policy."""
        return self.remove_named_policies("p", rules)

    def remove_filtered_policy(self, field_index, *field_values):
        """removes an authorization rule from the current policy, field filters can be specified."""
        return self.remove_filtered_named_policy("p", field_index, *field_values)

    def remove_named_policy(self, ptype, *params):
        """removes an authorization rule from the current named policy."""

        if len(params) == 1 and isinstance(params[0], list):
            str_slice = params[0]
            rule_removed = self._remove_policy("p", ptype, str_slice)
        else:
            rule_removed = self._remove_policy("p", ptype, list(params))

        return rule_removed

    def remove_named_policies(self, ptype, rules):
        """removes authorization rules from the current named policy."""
        return self._remove_policies("p", ptype, rules)

    def remove_filtered_named_policy(self, ptype, field_index, *field_values):
        """removes an authorization rule from the current named policy, field filters can be specified."""
        return self._remove_filtered_policy("p", ptype, field_index, *field_values)

    def has_grouping_policy(self, *params):
        """determines whether a role inheritance rule exists."""

        return self.has_named_grouping_policy("g", *params)

    def has_named_grouping_policy(self, ptype, *params):
        """determines whether a named role inheritance rule exists."""

        if len(params) == 1 and isinstance(params[0], list):
            str_slice = params[0]
            return self.model.has_policy("g", ptype, str_slice)

        return self.model.has_policy("g", ptype, list(params))

    def add_grouping_policy(self, *params):
        """adds a role inheritance rule to the current policy.

        If the rule already exists, the function returns false and the rule will not be added.
        Otherwise the function returns true by adding the new rule.
        """
        return self.add_named_grouping_policy("g", *params)

    def add_grouping_policies(self, rules):
        """adds role inheritance rulea to the current policy.

        If the rule already exists, the function returns false for the corresponding policy rule and the rule will not be added.
        Otherwise the function returns true for the corresponding policy rule by adding the new rule.
        """
        return self.add_named_grouping_policies("g", rules)

    def add_named_grouping_policy(self, ptype, *params):
        """adds a named role inheritance rule to the current policy.

        If the rule already exists, the function returns false and the rule will not be added.
        Otherwise the function returns true by adding the new rule.
        """

        rules = []
        if len(params) == 1 and isinstance(params[0], list):
            str_slice = params[0]
            rule_added = self._add_policy("g", ptype, str_slice)
            rules.append(str_slice)
        else:
            rule_added = self._add_policy("g", ptype, list(params))
            rules.append(list(params))

        if self.auto_build_role_links:
            self.model.build_incremental_role_links(
                self.rm_map[ptype], PolicyOp.Policy_add, "g", ptype, rules
            )
        return rule_added

    def add_named_grouping_policies(self, ptype, rules):
        """ "adds named role inheritance rules to the current policy.

        If the rule already exists, the function returns false for the corresponding policy rule and the rule will not be added.
        Otherwise the function returns true for the corresponding policy rule by adding the new rule."""
        rules_added = self._add_policies("g", ptype, rules)
        if self.auto_build_role_links:
            self.model.build_incremental_role_links(
                self.rm_map[ptype], PolicyOp.Policy_add, "g", ptype, rules
            )

        return rules_added

    def remove_grouping_policy(self, *params):
        """removes a role inheritance rule from the current policy."""
        return self.remove_named_grouping_policy("g", *params)

    def remove_grouping_policies(self, rules):
        """removes role inheritance rulea from the current policy."""
        return self.remove_named_grouping_policies("g", rules)

    def remove_filtered_grouping_policy(self, field_index, *field_values):
        """removes a role inheritance rule from the current policy, field filters can be specified."""
        return self.remove_filtered_named_grouping_policy(
            "g", field_index, *field_values
        )

    def remove_named_grouping_policy(self, ptype, *params):
        """removes a role inheritance rule from the current named policy."""

        rules = []
        if len(params) == 1 and isinstance(params[0], list):
            str_slice = params[0]
            rule_removed = self._remove_policy("g", ptype, str_slice)
            rules.append(str_slice)
        else:
            rule_removed = self._remove_policy("g", ptype, list(params))
            rules.append(list(params))

        if self.auto_build_role_links:
            self.model.build_incremental_role_links(
                self.rm_map[ptype], PolicyOp.Policy_remove, "g", ptype, rules
            )
        return rule_removed

    def remove_named_grouping_policies(self, ptype, rules):
        """removes role inheritance rules from the current named policy."""
        rules_removed = self._remove_policies("g", ptype, rules)

        if self.auto_build_role_links:
            self.model.build_incremental_role_links(
                self.rm_map[ptype], PolicyOp.Policy_remove, "g", ptype, rules
            )

        return rules_removed

    def remove_filtered_named_grouping_policy(self, ptype, field_index, *field_values):
        """removes a role inheritance rule from the current named policy, field filters can be specified."""
        rule_removed = self._remove_filtered_policy_returns_effects(
            "g", ptype, field_index, *field_values
        )

        if self.auto_build_role_links:
            self.model.build_incremental_role_links(
                self.rm_map[ptype], PolicyOp.Policy_remove, "g", ptype, rule_removed
            )
        return rule_removed

    def add_function(self, name, func):
        """adds a customized function."""
        self.fm.add_function(name, func)

1	# Copyright 2021 The casbin Authors. All Rights Reserved.
2	#
3	# Licensed under the Apache License, Version 2.0 (the "License");
4	# you may not use this file except in compliance with the License.
5	# You may obtain a copy of the License at
6	#
7	# http://www.apache.org/licenses/LICENSE-2.0
8	#
9	# Unless required by applicable law or agreed to in writing, software
10	# distributed under the License is distributed on an "AS IS" BASIS,
11	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	# See the License for the specific language governing permissions and
13	# limitations under the License.
14
15	from casbin.internal_enforcer import InternalEnforcer	12✔
16	from casbin.model.policy_op import PolicyOp	12✔
17
18
19	class ManagementEnforcer(InternalEnforcer):	12✔
20	"""
21	ManagementEnforcer = InternalEnforcer + Management API.
22	"""
23
24	def get_all_subjects(self):	12✔
25	"""gets the list of subjects that show up in the current policy."""
26	return self.get_all_named_subjects("p")	12✔
27
28	def get_all_named_subjects(self, ptype):	12✔
29	"""gets the list of subjects that show up in the current named policy."""
30	return self.model.get_values_for_field_in_policy("p", ptype, 0)	12✔
31
32	def get_all_objects(self):	12✔
33	"""gets the list of objects that show up in the current policy."""
34	return self.get_all_named_objects("p")	12✔
35
36	def get_all_named_objects(self, ptype):	12✔
37	"""gets the list of objects that show up in the current named policy."""
38	return self.model.get_values_for_field_in_policy("p", ptype, 1)	12✔
39
40	def get_all_actions(self):	12✔
41	"""gets the list of actions that show up in the current policy."""
42	return self.get_all_named_actions("p")	12✔
43
44	def get_all_named_actions(self, ptype):	12✔
45	"""gets the list of actions that show up in the current named policy."""
46	return self.model.get_values_for_field_in_policy("p", ptype, 2)	12✔
47
48	def get_all_roles(self):	12✔
49	"""gets the list of roles that show up in the current named policy."""
50	return self.get_all_named_roles("g")	12✔
51
52	def get_all_named_roles(self, ptype):	12✔
53	"""gets all the authorization rules in the policy."""
54	return self.model.get_values_for_field_in_policy("g", ptype, 1)	12✔
55
56	def get_policy(self):	12✔
57	"""gets all the authorization rules in the policy."""
58	return self.get_named_policy("p")	12✔
59
60	def get_filtered_policy(self, field_index, *field_values):	12✔
61	"""gets all the authorization rules in the policy, field filters can be specified."""
62	return self.get_filtered_named_policy("p", field_index, *field_values)	12✔
63
64	def get_named_policy(self, ptype):	12✔
65	"""gets all the authorization rules in the named policy."""
66	return self.model.get_policy("p", ptype)	12✔
67
68	def get_filtered_named_policy(self, ptype, field_index, *field_values):	12✔
69	"""gets all the authorization rules in the named policy, field filters can be specified."""
70	return self.model.get_filtered_policy("p", ptype, field_index, *field_values)	12✔
71
72	def get_grouping_policy(self):	12✔
73	"""gets all the role inheritance rules in the policy."""
74	return self.get_named_grouping_policy("g")	12✔
75
76	def get_filtered_grouping_policy(self, field_index, *field_values):	12✔
77	"""gets all the role inheritance rules in the policy, field filters can be specified."""
78	return self.get_filtered_named_grouping_policy("g", field_index, *field_values)	12✔
79
80	def get_named_grouping_policy(self, ptype):	12✔
81	"""gets all the role inheritance rules in the policy."""
82	return self.model.get_policy("g", ptype)	12✔
83
84	def get_filtered_named_grouping_policy(self, ptype, field_index, *field_values):	12✔
85	"""gets all the role inheritance rules in the policy, field filters can be specified."""
86	return self.model.get_filtered_policy("g", ptype, field_index, *field_values)	12✔
87
88	def has_policy(self, *params):	12✔
89	"""determines whether an authorization rule exists."""
90	return self.has_named_policy("p", *params)	12✔
91
92	def has_named_policy(self, ptype, *params):	12✔
93	"""determines whether a named authorization rule exists."""
94	if len(params) == 1 and isinstance(params[0], list):	12✔
95	str_slice = params[0]	12✔
96	return self.model.has_policy("p", ptype, str_slice)	12✔
97
98	return self.model.has_policy("p", ptype, list(params))	×
99
100	def add_policy(self, *params):	12✔
101	"""adds an authorization rule to the current policy.
102
103	If the rule already exists, the function returns false and the rule will not be added.
104	Otherwise the function returns true by adding the new rule.
105	"""
106	return self.add_named_policy("p", *params)	12✔
107
108	def add_policies(self, rules):	12✔
109	"""adds authorization rules to the current policy.
110
111	If the rule already exists, the function returns false for the corresponding rule and the rule will not be added.
112	Otherwise the function returns true for the corresponding rule by adding the new rule.
113	"""
114	return self.add_named_policies("p", rules)	12✔
115
116	def add_named_policy(self, ptype, *params):	12✔
117	"""adds an authorization rule to the current named policy.
118
119	If the rule already exists, the function returns false and the rule will not be added.
120	Otherwise the function returns true by adding the new rule.
121	"""
122
123	if len(params) == 1 and isinstance(params[0], list):	12✔
124	str_slice = params[0]	12✔
125	rule_added = self._add_policy("p", ptype, str_slice)	12✔
126	else:
127	rule_added = self._add_policy("p", ptype, list(params))	12✔
128
129	return rule_added	12✔
130
131	def add_named_policies(self, ptype, rules):	12✔
132	"""adds authorization rules to the current named policy.
133
134	If the rule already exists, the function returns false for the corresponding rule and the rule will not be added.
135	Otherwise the function returns true for the corresponding by adding the new rule."""
136	return self._add_policies("p", ptype, rules)	12✔
137
138	def update_policy(self, old_rule, new_rule):	12✔
139	"""updates an authorization rule from the current policy."""
140	return self.update_named_policy("p", old_rule, new_rule)	×
141
142	def update_policies(self, old_rules, new_rules):	12✔
143	"""updates authorization rules from the current policy."""
144	return self.update_named_policies("p", old_rules, new_rules)	×
145
146	def update_named_policy(self, ptype, old_rule, new_rule):	12✔
147	"""updates an authorization rule from the current named policy."""
148	return self._update_policy("p", ptype, old_rule, new_rule)	×
149
150	def update_named_policies(self, ptype, old_rules, new_rules):	12✔
151	"""updates authorization rules from the current named policy."""
152	return self._update_policies("p", ptype, old_rules, new_rules)	×
153
154	def update_filtered_policies(self, new_rules, field_index, *field_values):	12✔
155	"""update_filtered_policies deletes old rules and adds new rules."""
NEW 156	return self.update_filtered_named_policies(	×
157	"p", new_rules, field_index, *field_values
158	)
159
160	def update_filtered_named_policies(	12✔
161	self, ptype, new_rules, field_index, *field_values
162	):
163	"""update_filtered_named_policies deletes old rules and adds new rules."""
NEW 164	return self._update_filtered_policies(	×
165	"p", ptype, new_rules, field_index, *field_values
166	)
167
168	def remove_policy(self, *params):	12✔
169	"""removes an authorization rule from the current policy."""
170	return self.remove_named_policy("p", *params)	12✔
171
172	def remove_policies(self, rules):	12✔
173	"""removes authorization rules from the current policy."""
174	return self.remove_named_policies("p", rules)	12✔
175
176	def remove_filtered_policy(self, field_index, *field_values):	12✔
177	"""removes an authorization rule from the current policy, field filters can be specified."""
178	return self.remove_filtered_named_policy("p", field_index, *field_values)	12✔
179
180	def remove_named_policy(self, ptype, *params):	12✔
181	"""removes an authorization rule from the current named policy."""
182
183	if len(params) == 1 and isinstance(params[0], list):	12✔
184	str_slice = params[0]	12✔
185	rule_removed = self._remove_policy("p", ptype, str_slice)	12✔
186	else:
187	rule_removed = self._remove_policy("p", ptype, list(params))	×
188
189	return rule_removed	12✔
190
191	def remove_named_policies(self, ptype, rules):	12✔
192	"""removes authorization rules from the current named policy."""
193	return self._remove_policies("p", ptype, rules)	12✔
194
195	def remove_filtered_named_policy(self, ptype, field_index, *field_values):	12✔
196	"""removes an authorization rule from the current named policy, field filters can be specified."""
197	return self._remove_filtered_policy("p", ptype, field_index, *field_values)	12✔
198
199	def has_grouping_policy(self, *params):	12✔
200	"""determines whether a role inheritance rule exists."""
201
202	return self.has_named_grouping_policy("g", *params)	12✔
203
204	def has_named_grouping_policy(self, ptype, *params):	12✔
205	"""determines whether a named role inheritance rule exists."""
206
207	if len(params) == 1 and isinstance(params[0], list):	12✔
208	str_slice = params[0]	12✔
209	return self.model.has_policy("g", ptype, str_slice)	12✔
210
211	return self.model.has_policy("g", ptype, list(params))	×
212
213	def add_grouping_policy(self, *params):	12✔
214	"""adds a role inheritance rule to the current policy.
215
216	If the rule already exists, the function returns false and the rule will not be added.
217	Otherwise the function returns true by adding the new rule.
218	"""
219	return self.add_named_grouping_policy("g", *params)	12✔
220
221	def add_grouping_policies(self, rules):	12✔
222	"""adds role inheritance rulea to the current policy.
223
224	If the rule already exists, the function returns false for the corresponding policy rule and the rule will not be added.
225	Otherwise the function returns true for the corresponding policy rule by adding the new rule.
226	"""
227	return self.add_named_grouping_policies("g", rules)	×
228
229	def add_named_grouping_policy(self, ptype, *params):	12✔
230	"""adds a named role inheritance rule to the current policy.
231
232	If the rule already exists, the function returns false and the rule will not be added.
233	Otherwise the function returns true by adding the new rule.
234	"""
235
236	rules = []	12✔
237	if len(params) == 1 and isinstance(params[0], list):	12✔
238	str_slice = params[0]	×
239	rule_added = self._add_policy("g", ptype, str_slice)	×
240	rules.append(str_slice)	×
241	else:
242	rule_added = self._add_policy("g", ptype, list(params))	12✔
243	rules.append(list(params))	12✔
244
245	if self.auto_build_role_links:	12✔
246	self.model.build_incremental_role_links(	12✔
247	self.rm_map[ptype], PolicyOp.Policy_add, "g", ptype, rules
248	)
249	return rule_added	12✔
250
251	def add_named_grouping_policies(self, ptype, rules):	12✔
252	""" "adds named role inheritance rules to the current policy.
253
254	If the rule already exists, the function returns false for the corresponding policy rule and the rule will not be added.
255	Otherwise the function returns true for the corresponding policy rule by adding the new rule."""
256	rules_added = self._add_policies("g", ptype, rules)	×
257	if self.auto_build_role_links:	×
258	self.model.build_incremental_role_links(	×
259	self.rm_map[ptype], PolicyOp.Policy_add, "g", ptype, rules
260	)
261
262	return rules_added	×
263
264	def remove_grouping_policy(self, *params):	12✔
265	"""removes a role inheritance rule from the current policy."""
266	return self.remove_named_grouping_policy("g", *params)	12✔
267
268	def remove_grouping_policies(self, rules):	12✔
269	"""removes role inheritance rulea from the current policy."""
270	return self.remove_named_grouping_policies("g", rules)	×
271
272	def remove_filtered_grouping_policy(self, field_index, *field_values):	12✔
273	"""removes a role inheritance rule from the current policy, field filters can be specified."""
274	return self.remove_filtered_named_grouping_policy(	12✔
275	"g", field_index, *field_values
276	)
277
278	def remove_named_grouping_policy(self, ptype, *params):	12✔
279	"""removes a role inheritance rule from the current named policy."""
280
281	rules = []	12✔
282	if len(params) == 1 and isinstance(params[0], list):	12✔
283	str_slice = params[0]	×
284	rule_removed = self._remove_policy("g", ptype, str_slice)	×
285	rules.append(str_slice)	×
286	else:
287	rule_removed = self._remove_policy("g", ptype, list(params))	12✔
288	rules.append(list(params))	12✔
289
290	if self.auto_build_role_links:	12✔
291	self.model.build_incremental_role_links(	12✔
292	self.rm_map[ptype], PolicyOp.Policy_remove, "g", ptype, rules
293	)
294	return rule_removed	12✔
295
296	def remove_named_grouping_policies(self, ptype, rules):	12✔
297	"""removes role inheritance rules from the current named policy."""
298	rules_removed = self._remove_policies("g", ptype, rules)	×
299
300	if self.auto_build_role_links:	×
301	self.model.build_incremental_role_links(	×
302	self.rm_map[ptype], PolicyOp.Policy_remove, "g", ptype, rules
303	)
304
305	return rules_removed	×
306
307	def remove_filtered_named_grouping_policy(self, ptype, field_index, *field_values):	12✔
308	"""removes a role inheritance rule from the current named policy, field filters can be specified."""
309	rule_removed = self._remove_filtered_policy_returns_effects(	12✔
310	"g", ptype, field_index, *field_values
311	)
312
313	if self.auto_build_role_links:	12✔
314	self.model.build_incremental_role_links(	12✔
315	self.rm_map[ptype], PolicyOp.Policy_remove, "g", ptype, rule_removed
316	)
317	return rule_removed	12✔
318
319	def add_function(self, name, func):	12✔
320	"""adds a customized function."""
321	self.fm.add_function(name, func)	12✔

casbin / pycasbin / 2164857532

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous