2306785240

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/ee67ac28ccaa47dd99238c90da543abd4713dcdf">ee67ac28c<a href="https://github.com/casbin/pycasbin/commit/ee67ac28ccaa47dd99238c90da543abd4713dcdf">&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/ee67ac28ccaa47dd99238c90da543abd4713dcdf&quot;&gt;ee67ac28c&lt;/a&gt;&lt;a href=&quot;https://github.com/casbin/pycasbin/commit/ee67ac28ccaa47dd99238c90da543abd4713dcdf&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/casbin/pycasbin/commit/ee67ac28ccaa47dd99238c90da543abd&lt;/a&gt;4713dcdf">&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/casbin/pycasbin/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/casbin/pycasbin/commit/<a class="double-link" href="https://github.com/casbin/pycasbin/commit/6f6a2bf6a5cd1a6a63c6b8ba9b304f44096829d5">6f6a2bf6a</a><a href="https://github.com/casbin/pycasbin/commit/ee67ac28ccaa47dd99238c90da543abd4713dcdf">&amp;quot;&amp;gt;6f6a2bf6a&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;6f6a2bf6a&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/casbin/pycasbin/commit/ee67ac28ccaa47dd99238c90da543abd4713d&lt;/a&gt;cdf&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/casbin/pycasbin/commit/<a class="double-link" href="https://github.com/casbin/pycasbin/commit/810073426">810073426">810073426</a>

Pull Request Pull Request #257: fix issue #250

Run Details

2 of 4 new or added lines in 2 files covered. (50.0%)

1941 of 2280 relevant lines covered (85.13%)

10.21 hits per line

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

95.0

/casbin/rbac/default_role_manager/role_manager.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.

import logging
from collections import namedtuple
from enum import Enum

from casbin.rbac import RoleManager as RM

Link = namedtuple("Link", ["user", "role"])


class MatchOrder(Enum):
    STR_PATTERN = 0
    PATTERN_STR = 1
    PATTERN_PATTERN = 2


class Role:
    def __init__(self, name):
        self.name = name
        self.roles = set()
        self.users = set()

    def add_role(self, role):
        self.roles.add(role)
        role._add_user(self)

    def remove_role(self, role):
        self.roles.remove(role)
        role._remove_user(self)

    def _add_user(self, user):
        self.users.add(user)

    def _remove_user(self, user):
        self.users.remove(user)

    def copy_from(self, role):
        for r in role.roles:
            self.add_role(r)
        for u in role.users:
            u.add_role(self)

    def empty(self):
        return len(self.users) + len(self.roles) == 0

    def to_string(self):
        if len(self.roles) == 0:
            return ""

        names = ", ".join(self.get_roles())

        if len(self.roles) == 1:
            return self.name + " < " + names
        else:
            return self.name + " < (" + names + ")"

    def get_roles(self):
        roles = []
        for role in self.roles:
            roles.append(role.name)

        return roles


class RoleManager(RM):
    """provides a default implementation for the RoleManager interface"""

    def __init__(self, max_hierarchy_level=10):
        self.logger = logging.getLogger(__name__)
        self.max_hierarchy_level = max_hierarchy_level
        self.matching_func = None
        self.domain_matching_func = None
        self.all_links = list()
        self.all_roles = dict()

    def _rebuild(self):
        self.all_roles = dict()
        links = self.all_links
        self.all_links = list()
        for link in links:
            self.add_link(link.user, link.role)

    def _matching_fn(self, str1, str2, match_order=MatchOrder.STR_PATTERN):
        if match_order == MatchOrder.PATTERN_STR:
            return match_error_handler(self.matching_func, str2, str1)
        elif match_order == MatchOrder.PATTERN_PATTERN:
            return match_error_handler(self.matching_func, str1, str2) or match_error_handler(
                self.matching_func, str2, str1
            )
        else:  # match_order == MatchOrder.STR_PATTERN
            return match_error_handler(self.matching_func, str1, str2)

    def _matching_roles(self, name, match_order=MatchOrder.STR_PATTERN):
        return [
            role
            for role_name, role in list(
                self.all_roles.items()
            )  # convert view to list to avoid RuntimeError: dictionary changed size during iteration
            if self._matching_fn(name, role_name, match_order)
        ]

    def _get_role(self, name):
        if name not in self.all_roles:
            role = Role(name)
            if self.matching_func != None:
                for pattern_role in self._matching_roles(name):
                    role.copy_from(pattern_role)
            self.all_roles[name] = role
        return self.all_roles[name]

    def add_matching_func(self, fn):
        self.matching_func = fn
        self._rebuild()

    def add_domain_matching_func(self, fn=None):
        self.domain_matching_func = fn

    def clear(self):
        self.all_roles = dict()
        self.all_links = list()

    def add_link(self, name1, name2, *domain):
        self.all_links.append(Link(name1, name2))

        user = self._get_role(name1)
        role = self._get_role(name2)

        user.add_role(role)

        if self.matching_func != None:
            for r in self.all_roles.values():
                if r.name != user.name and self._matching_fn(user.name, r.name, MatchOrder.PATTERN_STR):
                    r.add_role(role)
                if r.name != role.name and self._matching_fn(role.name, r.name, MatchOrder.PATTERN_STR):
                    role.add_role(r)

    def delete_link(self, name1, name2, *domain):
        if Link(name1, name2) not in self.all_links:
            raise RuntimeError(f"error: link between {name1} and {name2} does not exist")
        self.all_links.remove(Link(name1, name2))

        user = self._get_role(name1)
        role = self._get_role(name2)
        user.remove_role(role)

        for r in self.all_roles.values():
            if r.name != user.name and self._matching_fn(user.name, r.name, MatchOrder.PATTERN_STR):
                r.remove_role(role)
            if r.name != role.name and self._matching_fn(role.name, r.name, MatchOrder.PATTERN_STR):
                role.remove_role(r)

    def has_link(self, name1, name2, *domain):
        user = self._get_role(name1)
        role = self._get_role(name2)

        return self._has_link(name2, [user], self.max_hierarchy_level)

    def _has_link(self, name, roles, level):
        if level <= 0 or len(roles) == 0:
            return False

        next_roles = set()
        for role in roles:
            if name == role.name:
                return True
            next_roles.update(set(role.roles))

        return self._has_link(name, list(next_roles), level - 1)

    def get_roles(self, name, *domain):
        user = self._get_role(name)
        return [r.name for r in user.roles]

    def get_users(self, name, *domain):
        role = self._get_role(name)
        return [u.name for u in role.users]

    def to_string(self):
        line = []
        for role in self.all_roles.values():
            text = role.to_string()
            if text:
                line.append(text)
        return ", ".join(line)

    def print_roles(self):
        self.logger.info(self.to_string())


class DomainManagerBase(RM):
    def __init__(self, max_hierarchy_level=10):
        self.logger = logging.getLogger(__name__)
        self.all_links = dict()
        self.max_hierarchy_level = max_hierarchy_level
        self.matching_func = None
        self.domain_matching_func = None
        self.matching_func = lambda name1, name2: name1 == name2

    def add_matching_func(self, fn):
        self.matching_func = fn

    def add_domain_matching_func(self, fn=None):
        self.domain_matching_func = fn

    def _get_domain(self, *domain):
        if len(domain) > 1:
            raise RuntimeError("error: domain should be 1 parameter")
        elif len(domain) == 1:
            domain = domain[0]
        else:
            domain = ""

        return domain

    def _get_links(self, *domain):
        domain = self._get_domain(*domain)

        if domain not in self.all_links:
            self.all_links[domain] = []

        return self.all_links[domain]

    def _get_role_manager(self, *domain):
        domain1 = self._get_domain(*domain)
        domain_links = self.all_links.get(domain1, [])

        if self.domain_matching_func != None:
            for domain2, links in self.all_links.items():
                if domain1 != domain2 and match_error_handler(self.domain_matching_func, domain1, domain2):
                    domain_links = domain_links + links

        rm = RoleManager(max_hierarchy_level=self.max_hierarchy_level)
        rm.add_matching_func(self.matching_func)
        for link in domain_links:
            rm.add_link(link[0], link[1])
        return rm

    def clear(self):
        self.all_links = dict()

    def add_link(self, name1, name2, *domain):
        links = self._get_links(*domain)
        links.append(Link(name1, name2))

    def delete_link(self, name1, name2, *domain):
        links = self._get_links(*domain)
        if Link(name1, name2) not in links:
            raise RuntimeError(f"error: link between {name1} and {name2} does not exist")
        links.remove(Link(name1, name2))

    def has_link(self, name1, name2, *domain):
        rm = self._get_role_manager(*domain)
        return rm.has_link(name1, name2)

    def get_roles(self, name, *domain):
        rm = self._get_role_manager(*domain)
        return rm.get_roles(name)

    def get_users(self, name, *domain):
        rm = self._get_role_manager(*domain)
        return rm.get_users(name)

    def print_roles(self):
        pass


class DomainManager(DomainManagerBase):
    def __init__(self, max_hierarchy_level=10):
        super().__init__(max_hierarchy_level)
        self.rm_map = dict()  # type: dict[str, RoleManager]

    def _rebuild(self):
        self.rm_map = dict()

    def _get_role_manager(self, *domain):
        domain1 = self._get_domain(*domain)
        if domain1 not in self.rm_map:
            self.rm_map[domain1] = super()._get_role_manager(*domain)

        return self.rm_map[domain1]

    def _affected_role_managers(self, *domain):
        domain_pattern = self._get_domain(*domain)

        if self.domain_matching_func != None:
            return [
                self.rm_map[domain_str]
                for domain_str in self.rm_map.keys()
                if match_error_handler(self.domain_matching_func, domain_str, domain_pattern)
            ]
        else:
            return [self.rm_map[domain_pattern]] if domain_pattern in self.rm_map else []

    def add_matching_func(self, fn):
        super().add_matching_func(fn)
        for rm in self.rm_map.values():
            rm.add_matching_func(fn)

    def add_domain_matching_func(self, fn):
        super().add_domain_matching_func(fn)
        for rm in self.rm_map.values():
            rm.add_domain_matching_func(fn)
        self._rebuild()

    def clear(self):
        super().clear()
        self.rm_map = dict()

    def add_link(self, name1, name2, *domain):
        super().add_link(name1, name2, *domain)
        for rm in self._affected_role_managers(*domain):
            rm.add_link(name1, name2, *domain)

    def delete_link(self, name1, name2, *domain):
        super().delete_link(name1, name2, *domain)
        for rm in self._affected_role_managers(*domain):
            rm.delete_link(name1, name2, *domain)

    def has_link(self, name1, name2, *domain):
        return super().has_link(name1, name2, *domain)

    def get_roles(self, name, *domain):
        return super().get_roles(name, *domain)

    def get_users(self, name, *domain):
        return super().get_users(name, *domain)

    def print_roles(self):
        for domain, rm in self.rm_map.items():
            line = rm.to_string()
            self.logger.info(f"{domain}: {line}")


def match_error_handler(fn, key1, key2):
    try:
        return fn(key1, key2)
    except:
        return False

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	import logging	12✔
16	from collections import namedtuple	12✔
17	from enum import Enum	12✔
18
19	from casbin.rbac import RoleManager as RM	12✔
20
21	Link = namedtuple("Link", ["user", "role"])	12✔
22
23
24	class MatchOrder(Enum):	12✔
25	STR_PATTERN = 0	12✔
26	PATTERN_STR = 1	12✔
27	PATTERN_PATTERN = 2	12✔
28
29
30	class Role:	12✔
31	def __init__(self, name):	12✔
32	self.name = name	12✔
33	self.roles = set()	12✔
34	self.users = set()	12✔
35
36	def add_role(self, role):	12✔
37	self.roles.add(role)	12✔
38	role._add_user(self)	12✔
39
40	def remove_role(self, role):	12✔
41	self.roles.remove(role)	12✔
42	role._remove_user(self)	12✔
43
44	def _add_user(self, user):	12✔
45	self.users.add(user)	12✔
46
47	def _remove_user(self, user):	12✔
48	self.users.remove(user)	12✔
49
50	def copy_from(self, role):	12✔
51	for r in role.roles:	12✔
52	self.add_role(r)	12✔
53	for u in role.users:	12✔
54	u.add_role(self)	12✔
55
56	def empty(self):	12✔
57	return len(self.users) + len(self.roles) == 0	×
58
59	def to_string(self):	12✔
60	if len(self.roles) == 0:	12✔
61	return ""	12✔
62
63	names = ", ".join(self.get_roles())	12✔
64
65	if len(self.roles) == 1:	12✔
66	return self.name + " < " + names	12✔
67	else:
68	return self.name + " < (" + names + ")"	12✔
69
70	def get_roles(self):	12✔
71	roles = []	12✔
72	for role in self.roles:	12✔
73	roles.append(role.name)	12✔
74
75	return roles	12✔
76
77
78	class RoleManager(RM):	12✔
79	"""provides a default implementation for the RoleManager interface"""
80
81	def __init__(self, max_hierarchy_level=10):	12✔
82	self.logger = logging.getLogger(__name__)	12✔
83	self.max_hierarchy_level = max_hierarchy_level	12✔
84	self.matching_func = None	12✔
85	self.domain_matching_func = None	12✔
86	self.all_links = list()	12✔
87	self.all_roles = dict()	12✔
88
89	def _rebuild(self):	12✔
90	self.all_roles = dict()	12✔
91	links = self.all_links	12✔
92	self.all_links = list()	12✔
93	for link in links:	12✔
94	self.add_link(link.user, link.role)	12✔
95
96	def _matching_fn(self, str1, str2, match_order=MatchOrder.STR_PATTERN):	12✔
97	if match_order == MatchOrder.PATTERN_STR:	12✔
98	return match_error_handler(self.matching_func, str2, str1)	12✔
99	elif match_order == MatchOrder.PATTERN_PATTERN:	12✔
100	return match_error_handler(self.matching_func, str1, str2) or match_error_handler(	×
101	self.matching_func, str2, str1
102	)
103	else: # match_order == MatchOrder.STR_PATTERN
104	return match_error_handler(self.matching_func, str1, str2)	12✔
105
106	def _matching_roles(self, name, match_order=MatchOrder.STR_PATTERN):	12✔
107	return [	12✔
108	role
109	for role_name, role in list(
110	self.all_roles.items()
111	) # convert view to list to avoid RuntimeError: dictionary changed size during iteration
112	if self._matching_fn(name, role_name, match_order)
113	]
114
115	def _get_role(self, name):	12✔
116	if name not in self.all_roles:	12✔
117	role = Role(name)	12✔
118	if self.matching_func != None:	12✔
119	for pattern_role in self._matching_roles(name):	12✔
120	role.copy_from(pattern_role)	12✔
121	self.all_roles[name] = role	12✔
122	return self.all_roles[name]	12✔
123
124	def add_matching_func(self, fn):	12✔
125	self.matching_func = fn	12✔
126	self._rebuild()	12✔
127
128	def add_domain_matching_func(self, fn=None):	12✔
129	self.domain_matching_func = fn	×
130
131	def clear(self):	12✔
132	self.all_roles = dict()	12✔
133	self.all_links = list()	12✔
134
135	def add_link(self, name1, name2, *domain):	12✔
136	self.all_links.append(Link(name1, name2))	12✔
137
138	user = self._get_role(name1)	12✔
139	role = self._get_role(name2)	12✔
140
141	user.add_role(role)	12✔
142
143	if self.matching_func != None:	12✔
144	for r in self.all_roles.values():	12✔
145	if r.name != user.name and self._matching_fn(user.name, r.name, MatchOrder.PATTERN_STR):	12✔
146	r.add_role(role)	12✔
147	if r.name != role.name and self._matching_fn(role.name, r.name, MatchOrder.PATTERN_STR):	12✔
148	role.add_role(r)	12✔
149
150	def delete_link(self, name1, name2, *domain):	12✔
151	if Link(name1, name2) not in self.all_links:	12✔
NEW 152	raise RuntimeError(f"error: link between {name1} and {name2} does not exist")	×
153	self.all_links.remove(Link(name1, name2))	12✔
154
155	user = self._get_role(name1)	12✔
156	role = self._get_role(name2)	12✔
157	user.remove_role(role)	12✔
158
159	for r in self.all_roles.values():	12✔
160	if r.name != user.name and self._matching_fn(user.name, r.name, MatchOrder.PATTERN_STR):	12✔
161	r.remove_role(role)	12✔
162	if r.name != role.name and self._matching_fn(role.name, r.name, MatchOrder.PATTERN_STR):	12✔
163	role.remove_role(r)	×
164
165	def has_link(self, name1, name2, *domain):	12✔
166	user = self._get_role(name1)	12✔
167	role = self._get_role(name2)	12✔
168
169	return self._has_link(name2, [user], self.max_hierarchy_level)	12✔
170
171	def _has_link(self, name, roles, level):	12✔
172	if level <= 0 or len(roles) == 0:	12✔
173	return False	12✔
174
175	next_roles = set()	12✔
176	for role in roles:	12✔
177	if name == role.name:	12✔
178	return True	12✔
179	next_roles.update(set(role.roles))	12✔
180
181	return self._has_link(name, list(next_roles), level - 1)	12✔
182
183	def get_roles(self, name, *domain):	12✔
184	user = self._get_role(name)	12✔
185	return [r.name for r in user.roles]	12✔
186
187	def get_users(self, name, *domain):	12✔
188	role = self._get_role(name)	12✔
189	return [u.name for u in role.users]	12✔
190
191	def to_string(self):	12✔
192	line = []	12✔
193	for role in self.all_roles.values():	12✔
194	text = role.to_string()	12✔
195	if text:	12✔
196	line.append(text)	12✔
197	return ", ".join(line)	12✔
198
199	def print_roles(self):	12✔
200	self.logger.info(self.to_string())	12✔
201
202
203	class DomainManagerBase(RM):	12✔
204	def __init__(self, max_hierarchy_level=10):	12✔
205	self.logger = logging.getLogger(__name__)	12✔
206	self.all_links = dict()	12✔
207	self.max_hierarchy_level = max_hierarchy_level	12✔
208	self.matching_func = None	12✔
209	self.domain_matching_func = None	12✔
210	self.matching_func = lambda name1, name2: name1 == name2	12✔
211
212	def add_matching_func(self, fn):	12✔
213	self.matching_func = fn	12✔
214
215	def add_domain_matching_func(self, fn=None):	12✔
216	self.domain_matching_func = fn	12✔
217
218	def _get_domain(self, *domain):	12✔
219	if len(domain) > 1:	12✔
220	raise RuntimeError("error: domain should be 1 parameter")	×
221	elif len(domain) == 1:	12✔
222	domain = domain[0]	12✔
223	else:
224	domain = ""	12✔
225
226	return domain	12✔
227
228	def _get_links(self, *domain):	12✔
229	domain = self._get_domain(*domain)	12✔
230
231	if domain not in self.all_links:	12✔
232	self.all_links[domain] = []	12✔
233
234	return self.all_links[domain]	12✔
235
236	def _get_role_manager(self, *domain):	12✔
237	domain1 = self._get_domain(*domain)	12✔
238	domain_links = self.all_links.get(domain1, [])	12✔
239
240	if self.domain_matching_func != None:	12✔
241	for domain2, links in self.all_links.items():	12✔
242	if domain1 != domain2 and match_error_handler(self.domain_matching_func, domain1, domain2):	12✔
243	domain_links = domain_links + links	12✔
244
245	rm = RoleManager(max_hierarchy_level=self.max_hierarchy_level)	12✔
246	rm.add_matching_func(self.matching_func)	12✔
247	for link in domain_links:	12✔
248	rm.add_link(link[0], link[1])	12✔
249	return rm	12✔
250
251	def clear(self):	12✔
252	self.all_links = dict()	12✔
253
254	def add_link(self, name1, name2, *domain):	12✔
255	links = self._get_links(*domain)	12✔
256	links.append(Link(name1, name2))	12✔
257
258	def delete_link(self, name1, name2, *domain):	12✔
259	links = self._get_links(*domain)	12✔
260	if Link(name1, name2) not in links:	12✔
261	raise RuntimeError(f"error: link between {name1} and {name2} does not exist")	×
262	links.remove(Link(name1, name2))	12✔
263
264	def has_link(self, name1, name2, *domain):	12✔
265	rm = self._get_role_manager(*domain)	12✔
266	return rm.has_link(name1, name2)	12✔
267
268	def get_roles(self, name, *domain):	12✔
269	rm = self._get_role_manager(*domain)	12✔
270	return rm.get_roles(name)	12✔
271
272	def get_users(self, name, *domain):	12✔
273	rm = self._get_role_manager(*domain)	12✔
274	return rm.get_users(name)	12✔
275
276	def print_roles(self):	12✔
277	pass	×
278
279
280	class DomainManager(DomainManagerBase):	12✔
281	def __init__(self, max_hierarchy_level=10):	12✔
282	super().__init__(max_hierarchy_level)	12✔
283	self.rm_map = dict() # type: dict[str, RoleManager]	12✔
284
285	def _rebuild(self):	12✔
286	self.rm_map = dict()	12✔
287
288	def _get_role_manager(self, *domain):	12✔
289	domain1 = self._get_domain(*domain)	12✔
290	if domain1 not in self.rm_map:	12✔
291	self.rm_map[domain1] = super()._get_role_manager(*domain)	12✔
292
293	return self.rm_map[domain1]	12✔
294
295	def _affected_role_managers(self, *domain):	12✔
296	domain_pattern = self._get_domain(*domain)	12✔
297
298	if self.domain_matching_func != None:	12✔
299	return [	12✔
300	self.rm_map[domain_str]
301	for domain_str in self.rm_map.keys()
302	if match_error_handler(self.domain_matching_func, domain_str, domain_pattern)
303	]
304	else:
305	return [self.rm_map[domain_pattern]] if domain_pattern in self.rm_map else []	12✔
306
307	def add_matching_func(self, fn):	12✔
308	super().add_matching_func(fn)	12✔
309	for rm in self.rm_map.values():	12✔
310	rm.add_matching_func(fn)	×
311
312	def add_domain_matching_func(self, fn):	12✔
313	super().add_domain_matching_func(fn)	12✔
314	for rm in self.rm_map.values():	12✔
315	rm.add_domain_matching_func(fn)	×
316	self._rebuild()	12✔
317
318	def clear(self):	12✔
319	super().clear()	12✔
320	self.rm_map = dict()	12✔
321
322	def add_link(self, name1, name2, *domain):	12✔
323	super().add_link(name1, name2, *domain)	12✔
324	for rm in self._affected_role_managers(*domain):	12✔
325	rm.add_link(name1, name2, *domain)	12✔
326
327	def delete_link(self, name1, name2, *domain):	12✔
328	super().delete_link(name1, name2, *domain)	12✔
329	for rm in self._affected_role_managers(*domain):	12✔
330	rm.delete_link(name1, name2, *domain)	12✔
331
332	def has_link(self, name1, name2, *domain):	12✔
333	return super().has_link(name1, name2, *domain)	12✔
334
335	def get_roles(self, name, *domain):	12✔
336	return super().get_roles(name, *domain)	12✔
337
338	def get_users(self, name, *domain):	12✔
339	return super().get_users(name, *domain)	12✔
340
341	def print_roles(self):	12✔
342	for domain, rm in self.rm_map.items():	12✔
343	line = rm.to_string()	×
344	self.logger.info(f"{domain}: {line}")	×
345
346
347	def match_error_handler(fn, key1, key2):	12✔
348	try:	12✔
349	return fn(key1, key2)	12✔
350	except:	12✔
351	return False	12✔

casbin / pycasbin / 2306785240

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