3354397696

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/kobotoolbox/kpi/commit/<a class=hub.com/kobotoolbox/kpi/commit/<a class="double-link" href="https://git"><a class=hub.com/kobotoolbox/kpi/commit/<a class="double-link" href="https://git"><a class=hub.com/kobotoolbox/kpi/commit/<a class="double-link" href="https://git"><a class=hub.com/kobotoolbox/kpi/commit/<a class="double-link" href="https://git"><a class=hub.com/kobotoolbox/kpi/commit/f1c6162047e75bf313b52ca25b1b05c72c9b9cd7">f1c616204">&lt;a href=&quot;https://github.com/kobotoolbox/kpi/commit/</a><a class="double-link" href="https://github.com/kobotoolbox/kpi/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/kobotoolbox/kpi/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/kobotoolbox/kpi/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/kobotoolbox/kpi/commit/f1c6162047e75bf313b52ca25b1b05c72c9b9cd7">f1c616204</a><a href="https://github.com/kobotoolbox/kpi/commit/f1c6162047e75bf313b52ca25b1b05c72c9b9cd7">&lt;a href=&quot;https://github.com/kobotoolbox/kpi/commit/f1c6162047e75bf313b52ca25b1b05c72c9b9cd7&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/kobotoolbox/kpi/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/kobotoolbox/kpi/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;https://git&amp;quot;&amp;gt;&amp;amp;lt;a class=&amp;lt;/a&amp;gt;hub.com/kobotoolbox/kpi/commit/f1c6162047e75bf313b52ca25b1b05c72c9b9cd7&amp;quot;&amp;gt;f1c616204&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/kobotoolbox/kpi/commit/f1c6162047e75bf313b52ca25b1b05c72c9b9cd7&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/kobotoolbox/kpi/commit/f1c6162047e75bf313b52ca25b1b05c7&amp;lt;/a&amp;gt;2c9</a>b9cd7&quot;&gt;&amp;quot;&amp;gt;Merge &amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/kobotoolbox/kpi/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/kobotoolbox/kpi/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/kobotoolbox/kpi/commit/2cdde7af5&quot;&gt;2cdde7af5&lt;/a&gt;&lt;a href=&quot;htt... (continued)

Pull Request Pull Request #4091: Endpoints for regional views

Run Details

2258 of 3725 branches covered (60.62%)

113 of 113 new or added lines in 5 files covered. (100.0%)

9734 of 12801 relevant lines covered (76.04%)

1.52 hits per line

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

82.26

/kpi/utils/object_permission.py

# coding: utf-8
import json
from collections import defaultdict
from typing import Union

import constance
from django.apps import apps
from django.conf import settings
from django.contrib.auth.models import User, Permission, AnonymousUser
from django.contrib.contenttypes.models import ContentType
from django.db import models
from django.shortcuts import _get_queryset
from django_request_cache import cache_for_request
from rest_framework import serializers

from kpi.constants import PERM_MANAGE_ASSET, PERM_FROM_KC_ONLY
from kpi.utils.permissions import is_user_anonymous


def get_all_objects_for_user(user, klass):
    """
    Return all objects of type klass to which user has been assigned any
    permission.
    """
    if ('kpi', 'asset') != (klass._meta.app_label, klass._meta.model_name):
        # Transitioning away from generic-relation ObjectPermission
        raise NotImplementedError

    return klass.objects.filter(permissions__user=user).distinct()


@cache_for_request
def get_cached_code_names(model_: models.Model = None) -> dict:
    """
    Creates a dictionary from `auth_permission` table and saves it in cache
    during the request life.
    Avoids several accesses to DB to fetch permission ids (or names)
    which only change after migrations.

    Args:
        model_: Any model of `settings.INSTALLED_APPS`.
                It's narrowed down to `Asset` by default

    Returns:
        dict: a dictionary of code names and ids
    """
    if model_ is None:
        # referencing `Asset` this way avoids a circular import
        model_ = apps.get_model('kpi.asset')

    content_type = ContentType.objects.get_for_model(model_)

    records = Permission.objects.values('id', 'codename', 'name').filter(
        content_type=content_type)

    perm_ids_from_code_names = defaultdict(dict)
    for record in records:
        perm_ids_from_code_names[record['codename']] = {
            'id': record['id'],
            'name': record['name']
        }

    return perm_ids_from_code_names


@cache_for_request
def get_anonymous_user():
    """ Return a real User in the database to represent AnonymousUser. """
    try:
        user = User.objects.get(pk=settings.ANONYMOUS_USER_ID)
    except User.DoesNotExist:
        username = getattr(
            settings,
            'ANONYMOUS_DEFAULT_USERNAME_VALUE',
            'AnonymousUser'
        )
        user = User.objects.create(
            pk=settings.ANONYMOUS_USER_ID,
            username=username
        )
    return user


def get_database_user(user: Union[User, AnonymousUser]) -> User:
    """
    Returns a real `User` object if `user` is an `AnonymousUser`, otherwise
    returns `user` unchanged
    """
    if user.is_anonymous:
        user = get_anonymous_user()
    return user


def get_objects_for_user(
    user,
    perms,
    klass=None,
    all_perms_required=True,
):
    """
    A simplified version of django-guardian's get_objects_for_user shortcut.
    Returns queryset of objects for which a given ``user`` has *all*
    permissions present at ``perms``.
    :param user: ``User`` or ``AnonymousUser`` instance for which objects would
      be returned.
    :param perms: single permission string, or sequence of permission strings
      which should be checked.
      If ``klass`` parameter is not given, those should be full permission
      names rather than only codenames (i.e. ``auth.change_user``). If more than
      one permission is present within sequence, their content type **must** be
      the same or ``ValidationError`` exception will be raised.
    :param klass: may be a Model, Manager or QuerySet object. If not given
      this parameter will be computed based on given ``params``.
    :param all_perms_required: If False, users should have at least one
      of the `perms`
    """
    app_label = 'kpi'
    if klass is None:
        # referencing `Asset` this way avoids a circular import
        queryset = apps.get_model('kpi.asset').objects.all()
    else:
        queryset = _get_queryset(klass)
        if (app_label, 'asset') != (
            queryset.model._meta.app_label,
            queryset.model._meta.model_name,
        ):
            # Transitioning away from generic-relation ObjectPermission
            raise NotImplementedError

    if isinstance(perms, str):
        perms = [perms]

    codenames = set()
    # Compute codenames set
    for perm in perms:
        if '.' in perm:
            new_app_label, codename = perm.split('.', 1)
            if app_label != new_app_label:
                # Transitioning away from generic-relation ObjectPermission
                raise NotImplementedError
        else:
            codename = perm
        codenames.add(codename)

    # Check if the user is anonymous. The
    # django.contrib.auth.models.AnonymousUser object doesn't work for
    # queries, and it's nice to be able to pass in request.user blindly.
    user = get_database_user(user)

    if all_perms_required:
        for codename in codenames:
            perm_id = get_perm_ids_from_code_names(codename)
            queryset = queryset.filter(
                permissions__user=user,
                permissions__permission_id=perm_id,
                permissions__deny=False,
            )
        return queryset.distinct()
    else:
        perm_ids = get_perm_ids_from_code_names(codenames)
        return queryset.filter(
            permissions__user=user,
            permissions__permission_id__in=perm_ids,
            permissions__deny=False,
        ).distinct()


@cache_for_request
def get_perm_ids_from_code_names(
    code_names: Union[str, list, tuple, set], model_: models.Model = None
) -> Union[int, list]:
    """
    Returns id or a list of ids corresponding to `code_names`.

    Args:
        code_names (str/list): Code name or list of code names
        model_: Any model of `settings.INSTALLED_APPS`. It's narrowed down to
                `Asset` by default.

    Returns:
        int/list: id or list of ids
    """
    # `get_cached_code_names` handles defaulting `model_` to `kpi.Asset`
    perm_ids = get_cached_code_names(model_)
    if isinstance(code_names, (list, tuple, set)):
        return [v['id'] for k, v in perm_ids.items() if k in code_names]
    else:
        return perm_ids[code_names]['id']


def get_user_permission_assignments(
    affected_object, user, object_permission_assignments
):
    """
    Works like `get_user_permission_assignments_queryset` but returns
    a list instead of a queryset. It also needs a list of all
    `affected_object`'s permission assignments to search for assignments
    `user` is allowed to see.

    Args:
        affected_object (Asset)
        user (User)
        object_permission_assignments (list):
    Returns:
         list

    """
    user_permission_assignments = []
    filtered_user_ids = None

    if not user or is_user_anonymous(user):
        filtered_user_ids = [affected_object.owner_id]
    elif not affected_object.has_perm(user, PERM_MANAGE_ASSET):
        # Display only users' permissions if they are not allowed to modify
        # others' permissions
        filtered_user_ids = [affected_object.owner_id,
                             user.pk,
                             settings.ANONYMOUS_USER_ID]

    for permission_assignment in object_permission_assignments:
        if (filtered_user_ids is None or
                permission_assignment.user_id in filtered_user_ids):
            user_permission_assignments.append(permission_assignment)

    return user_permission_assignments


def get_user_permission_assignments_queryset(affected_object, user):
    """
    Returns a queryset to fetch `affected_object`'s permission assignments
    that `user` is allowed to see.

    Args:
        affected_object (Asset)
        user (User)
    Returns:
        QuerySet

    """

    # `affected_object.permissions` is a `GenericRelation(ObjectPermission)`
    # Don't Prefetch `content_object`.
    # See `AssetPermissionAssignmentSerializer.to_representation()`
    queryset = affected_object.permissions.filter(deny=False).select_related(
        'permission', 'user'
    ).order_by(
        'user__username', 'permission__codename'
    ).exclude(permission__codename=PERM_FROM_KC_ONLY).all()

    # Filtering is done in `get_queryset` instead of FilteredBackend class
    # because it's specific to `ObjectPermission`.
    if not user or is_user_anonymous(user):
        queryset = queryset.filter(
            user_id__in=[
                affected_object.owner_id,
                settings.ANONYMOUS_USER_ID,
            ]
        )
    elif not affected_object.has_perm(user, PERM_MANAGE_ASSET):
        # Display only users' permissions if they are not allowed to modify
        # others' permissions
        queryset = queryset.filter(user_id__in=[user.pk,
                                                affected_object.owner_id,
                                                settings.ANONYMOUS_USER_ID])

    return queryset


def perm_parse(perm, obj=None):
    if obj is not None:
        obj_app_label = ContentType.objects.get_for_model(obj).app_label
    else:
        obj_app_label = None
    try:
        app_label, codename = perm.split('.', 1)
        if obj_app_label is not None and app_label != obj_app_label:
            raise serializers.ValidationError(
                'The given object does not belong to the app '
                'specified in the permission string.'
            )

    except ValueError:
        app_label = obj_app_label
        codename = perm
    return app_label, codename


def get_regional_user_permissions(asset: 'models.Asset', user: 'auth.User') -> list:
    regional_views = json.loads(constance.config.REGIONAL_VIEWS)
    regional_assignments = json.loads(constance.config.REGIONAL_ASSIGNMENTS)

    def _get_asset_countries(asset: 'models.Asset') -> list:
        countries = asset.settings.get('country')
        if countries is not None and isinstance(countries, list):
            return [c['value'] for c in countries]
        return [countries['value']] if countries else []

    asset_countries = _get_asset_countries(asset)

    # views that asset is in
    views_for_asset = [
        view
        for view in regional_views
        if (set(asset_countries) & set(view['countries']))
        or ('*' == view['countries'])
    ]
    if not views_for_asset:
        return []

    # view ids that user is in
    view_ids_for_user = [
        v['view']
        for v in regional_assignments
        if v['username'] == user.username
    ]
    if not view_ids_for_user:
        return []

    # views that both the user and asset are in
    views_for_user_and_asset = [
        v for v in views_for_asset if v['id'] in view_ids_for_user
    ]
    if not views_for_user_and_asset:
        return []

    # permissions for asset
    return [perm for v in views_for_user_and_asset for perm in v['permissions']]


def user_has_regional_asset_perm(
    asset: 'models.Asset', user: 'auth.User', perm: str
) -> bool:
    return perm in get_regional_user_permissions(asset, user)

1	# coding: utf-8
2	import json	2✔
3	from collections import defaultdict	2✔
4	from typing import Union	2✔
5
6	import constance	2✔
7	from django.apps import apps	2✔
8	from django.conf import settings	2✔
9	from django.contrib.auth.models import User, Permission, AnonymousUser	2✔
10	from django.contrib.contenttypes.models import ContentType	2✔
11	from django.db import models	2✔
12	from django.shortcuts import _get_queryset	2✔
13	from django_request_cache import cache_for_request	2✔
14	from rest_framework import serializers	2✔
15
16	from kpi.constants import PERM_MANAGE_ASSET, PERM_FROM_KC_ONLY	2✔
17	from kpi.utils.permissions import is_user_anonymous	2✔
18
19
20	def get_all_objects_for_user(user, klass):	2✔
21	"""
22	Return all objects of type klass to which user has been assigned any
23	permission.
24	"""
25	if ('kpi', 'asset') != (klass._meta.app_label, klass._meta.model_name):	2!
26	# Transitioning away from generic-relation ObjectPermission
27	raise NotImplementedError	×
28
29	return klass.objects.filter(permissions__user=user).distinct()	2✔
30
31
32	@cache_for_request	2✔
33	def get_cached_code_names(model_: models.Model = None) -> dict:	2✔
34	"""
35	Creates a dictionary from `auth_permission` table and saves it in cache
36	during the request life.
37	Avoids several accesses to DB to fetch permission ids (or names)
38	which only change after migrations.
39
40	Args:
41	model_: Any model of `settings.INSTALLED_APPS`.
42	It's narrowed down to `Asset` by default
43
44	Returns:
45	dict: a dictionary of code names and ids
46	"""
47	if model_ is None:	2!
48	# referencing `Asset` this way avoids a circular import
49	model_ = apps.get_model('kpi.asset')	2✔
50
51	content_type = ContentType.objects.get_for_model(model_)	2✔
52
53	records = Permission.objects.values('id', 'codename', 'name').filter(	2✔
54	content_type=content_type)
55
56	perm_ids_from_code_names = defaultdict(dict)	2✔
57	for record in records:	2✔
58	perm_ids_from_code_names[record['codename']] = {	2✔
59	'id': record['id'],
60	'name': record['name']
61	}
62
63	return perm_ids_from_code_names	2✔
64
65
66	@cache_for_request	2✔
67	def get_anonymous_user():	2✔
68	""" Return a real User in the database to represent AnonymousUser. """
69	try:	2✔
70	user = User.objects.get(pk=settings.ANONYMOUS_USER_ID)	2✔
71	except User.DoesNotExist:	2✔
72	username = getattr(	2✔
73	settings,
74	'ANONYMOUS_DEFAULT_USERNAME_VALUE',
75	'AnonymousUser'
76	)
77	user = User.objects.create(	2✔
78	pk=settings.ANONYMOUS_USER_ID,
79	username=username
80	)
81	return user	2✔
82
83
84	def get_database_user(user: Union[User, AnonymousUser]) -> User:	2✔
85	"""
86	Returns a real `User` object if `user` is an `AnonymousUser`, otherwise
87	returns `user` unchanged
88	"""
89	if user.is_anonymous:	2✔
90	user = get_anonymous_user()	2✔
91	return user	2✔
92
93
94	def get_objects_for_user(	2✔
95	user,
96	perms,
97	klass=None,
98	all_perms_required=True,
99	):
100	"""
101	A simplified version of django-guardian's get_objects_for_user shortcut.
102	Returns queryset of objects for which a given ``user`` has all
103	permissions present at ``perms``.
104	:param user: ``User`` or ``AnonymousUser`` instance for which objects would
105	be returned.
106	:param perms: single permission string, or sequence of permission strings
107	which should be checked.
108	If ``klass`` parameter is not given, those should be full permission
109	names rather than only codenames (i.e. ``auth.change_user``). If more than
110	one permission is present within sequence, their content type must be
111	the same or ``ValidationError`` exception will be raised.
112	:param klass: may be a Model, Manager or QuerySet object. If not given
113	this parameter will be computed based on given ``params``.
114	:param all_perms_required: If False, users should have at least one
115	of the `perms`
116	"""
117	app_label = 'kpi'	2✔
118	if klass is None:	2!
119	# referencing `Asset` this way avoids a circular import
120	queryset = apps.get_model('kpi.asset').objects.all()	×
121	else:
122	queryset = _get_queryset(klass)	2✔
123	if (app_label, 'asset') != (	2!
124	queryset.model._meta.app_label,
125	queryset.model._meta.model_name,
126	):
127	# Transitioning away from generic-relation ObjectPermission
128	raise NotImplementedError	×
129
130	if isinstance(perms, str):	2✔
131	perms = [perms]	2✔
132
133	codenames = set()	2✔
134	# Compute codenames set
135	for perm in perms:	2✔
136	if '.' in perm:	2!
137	new_app_label, codename = perm.split('.', 1)	×
138	if app_label != new_app_label:	×
139	# Transitioning away from generic-relation ObjectPermission
140	raise NotImplementedError	×
141	else:
142	codename = perm	2✔
143	codenames.add(codename)	2✔
144
145	# Check if the user is anonymous. The
146	# django.contrib.auth.models.AnonymousUser object doesn't work for
147	# queries, and it's nice to be able to pass in request.user blindly.
148	user = get_database_user(user)	2✔
149
150	if all_perms_required:	2!
151	for codename in codenames:	2✔
152	perm_id = get_perm_ids_from_code_names(codename)	2✔
153	queryset = queryset.filter(	2✔
154	permissions__user=user,
155	permissions__permission_id=perm_id,
156	permissions__deny=False,
157	)
158	return queryset.distinct()	2✔
159	else:
160	perm_ids = get_perm_ids_from_code_names(codenames)	×
161	return queryset.filter(	×
162	permissions__user=user,
163	permissions__permission_id__in=perm_ids,
164	permissions__deny=False,
165	).distinct()
166
167
168	@cache_for_request	2✔
169	def get_perm_ids_from_code_names(	2✔
170	code_names: Union[str, list, tuple, set], model_: models.Model = None
171	) -> Union[int, list]:
172	"""
173	Returns id or a list of ids corresponding to `code_names`.
174
175	Args:
176	code_names (str/list): Code name or list of code names
177	model_: Any model of `settings.INSTALLED_APPS`. It's narrowed down to
178	`Asset` by default.
179
180	Returns:
181	int/list: id or list of ids
182	"""
183	# `get_cached_code_names` handles defaulting `model_` to `kpi.Asset`
184	perm_ids = get_cached_code_names(model_)	2✔
185	if isinstance(code_names, (list, tuple, set)):	2!
186	return [v['id'] for k, v in perm_ids.items() if k in code_names]	×
187	else:
188	return perm_ids[code_names]['id']	2✔
189
190
191	def get_user_permission_assignments(	2✔
192	affected_object, user, object_permission_assignments
193	):
194	"""
195	Works like `get_user_permission_assignments_queryset` but returns
196	a list instead of a queryset. It also needs a list of all
197	`affected_object`'s permission assignments to search for assignments
198	`user` is allowed to see.
199
200	Args:
201	affected_object (Asset)
202	user (User)
203	object_permission_assignments (list):
204	Returns:
205	list
206
207	"""
208	user_permission_assignments = []	2✔
209	filtered_user_ids = None	2✔
210
211	if not user or is_user_anonymous(user):	2!
212	filtered_user_ids = [affected_object.owner_id]	×
213	elif not affected_object.has_perm(user, PERM_MANAGE_ASSET):	2✔
214	# Display only users' permissions if they are not allowed to modify
215	# others' permissions
216	filtered_user_ids = [affected_object.owner_id,	2✔
217	user.pk,
218	settings.ANONYMOUS_USER_ID]
219
220	for permission_assignment in object_permission_assignments:	2✔
221	if (filtered_user_ids is None or	2!
222	permission_assignment.user_id in filtered_user_ids):
223	user_permission_assignments.append(permission_assignment)	2✔
224
225	return user_permission_assignments	2✔
226
227
228	def get_user_permission_assignments_queryset(affected_object, user):	2✔
229	"""
230	Returns a queryset to fetch `affected_object`'s permission assignments
231	that `user` is allowed to see.
232
233	Args:
234	affected_object (Asset)
235	user (User)
236	Returns:
237	QuerySet
238
239	"""
240
241	# `affected_object.permissions` is a `GenericRelation(ObjectPermission)`
242	# Don't Prefetch `content_object`.
243	# See `AssetPermissionAssignmentSerializer.to_representation()`
244	queryset = affected_object.permissions.filter(deny=False).select_related(	2✔
245	'permission', 'user'
246	).order_by(
247	'user__username', 'permission__codename'
248	).exclude(permission__codename=PERM_FROM_KC_ONLY).all()
249
250	# Filtering is done in `get_queryset` instead of FilteredBackend class
251	# because it's specific to `ObjectPermission`.
252	if not user or is_user_anonymous(user):	2✔
253	queryset = queryset.filter(	2✔
254	user_id__in=[
255	affected_object.owner_id,
256	settings.ANONYMOUS_USER_ID,
257	]
258	)
259	elif not affected_object.has_perm(user, PERM_MANAGE_ASSET):	2✔
260	# Display only users' permissions if they are not allowed to modify
261	# others' permissions
262	queryset = queryset.filter(user_id__in=[user.pk,	2✔
263	affected_object.owner_id,
264	settings.ANONYMOUS_USER_ID])
265
266	return queryset	2✔
267
268
269	def perm_parse(perm, obj=None):	2✔
270	if obj is not None:	2✔
271	obj_app_label = ContentType.objects.get_for_model(obj).app_label	2✔
272	else:
273	obj_app_label = None	2✔
274	try:	2✔
275	app_label, codename = perm.split('.', 1)	2✔
276	if obj_app_label is not None and app_label != obj_app_label:	2!
277	raise serializers.ValidationError(	×
278	'The given object does not belong to the app '
279	'specified in the permission string.'
280	)
281
282	except ValueError:	2✔
283	app_label = obj_app_label	2✔
284	codename = perm	2✔
285	return app_label, codename	2✔
286
287
288	def get_regional_user_permissions(asset: 'models.Asset', user: 'auth.User') -> list:	2✔
289	regional_views = json.loads(constance.config.REGIONAL_VIEWS)	2✔
290	regional_assignments = json.loads(constance.config.REGIONAL_ASSIGNMENTS)	2✔
291
292	def _get_asset_countries(asset: 'models.Asset') -> list:	2✔
293	countries = asset.settings.get('country')	2✔
294	if countries is not None and isinstance(countries, list):	2!
295	return [c['value'] for c in countries]	×
296	return [countries['value']] if countries else []	2✔
297
298	asset_countries = _get_asset_countries(asset)	2✔
299
300	# views that asset is in
301	views_for_asset = [	2✔
302	view
303	for view in regional_views
304	if (set(asset_countries) & set(view['countries']))
305	or ('*' == view['countries'])
306	]
307	if not views_for_asset:	2✔
308	return []	2✔
309
310	# view ids that user is in
311	view_ids_for_user = [	2✔
312	v['view']
313	for v in regional_assignments
314	if v['username'] == user.username
315	]
316	if not view_ids_for_user:	2!
317	return []	×
318
319	# views that both the user and asset are in
320	views_for_user_and_asset = [	2✔
321	v for v in views_for_asset if v['id'] in view_ids_for_user
322	]
323	if not views_for_user_and_asset:	2!
324	return []	×
325
326	# permissions for asset
327	return [perm for v in views_for_user_and_asset for perm in v['permissions']]	2✔
328
329
330	def user_has_regional_asset_perm(	2✔
331	asset: 'models.Asset', user: 'auth.User', perm: str
332	) -> bool:
333	return perm in get_regional_user_permissions(asset, user)	2✔

kobotoolbox / kpi / 3354397696

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