def test_create_and_delete_favorites(self):
"""
Ensure we can add and remove resources to user's favorite.
"""
dataset = get_resources_with_perms(get_user_model().objects.get(pk=-1)).first()
url = urljoin(f"{reverse('base-resources-list')}/", f"{dataset.pk}/favorite/")
# Anonymous
response = self.client.post(url, format='json')
self.assertEqual(response.status_code, 403)
# Authenticated user
self.assertTrue(self.client.login(username='******', password='******'))
response = self.client.post(url, format="json")
self.assertEqual(response.data["message"], "Successfuly added resource to favorites")
self.assertEqual(response.status_code, 201)
# add resource to favorite again
response = self.client.post(url, format="json")
self.assertEqual(response.data["message"], "Resource is already in favorites")
self.assertEqual(response.status_code, 400)
# remove resource from favorites
response = self.client.delete(url, format="json")
self.assertEqual(response.data["message"], "Successfuly removed resource from favorites")
self.assertEqual(response.status_code, 200)
# remove resource to favorite again
response = self.client.delete(url, format="json")
self.assertEqual(response.data["message"], "Resource not in favorites")
self.assertEqual(response.status_code, 404)
def resource_types(self, request):
resource_types = []
_types = []
for _model in apps.get_models():
if _model.__name__ == "ResourceBase":
for _m in _model.__subclasses__():
if _m.__name__.lower() not in ['service']:
_types.append(_m.__name__.lower())
if settings.GEONODE_APPS_ENABLE and 'geoapp' in _types:
_types.remove('geoapp')
if hasattr(settings, 'MAPSTORE_CLIENT_APP_LIST'
) and settings.MAPSTORE_CLIENT_APP_LIST:
_types += settings.MAPSTORE_CLIENT_APP_LIST
else:
from geonode.geoapps.models import GeoApp
geoapp_types = [
x for x in GeoApp.objects.values_list(
'resource_type', flat=True).all().distinct()
]
_types += geoapp_types
for _type in _types:
resource_types.append({
"name":
_type,
"count":
get_resources_with_perms(
request.user).filter(resource_type=_type).count()
})
return Response({"resource_types": resource_types})
def _filtered(self, request, filter):
paginator = GeoNodeApiPagination()
paginator.page_size = request.GET.get('page_size', 10)
resources = get_resources_with_perms(request.user).filter(**filter)
result_page = paginator.paginate_queryset(resources, request)
serializer = ResourceBaseSerializer(result_page, embed=True, many=True)
return paginator.get_paginated_response({"resources": serializer.data})
def to_representation(self, instance):
request = self.context.get('request')
filter_options = {}
if request.query_params:
filter_options = {
'type_filter': request.query_params.get('type'),
'title_filter': request.query_params.get('title__icontains')
}
data = super().to_representation(instance)
count_filter = {self.Meta.count_type: instance}
data['count'] = get_resources_with_perms(
request.user, filter_options).filter(**count_filter).count()
return data
def _filtered(request, resources, serializer):
try:
paginator = GeoNodeApiPagination()
paginator.page_size = request.GET.get('page_size', 10)
user_resources = get_resources_with_perms(request.user)
resources = resources.filter(id__in=user_resources)
result_page = paginator.paginate_queryset(resources, request)
resource_type_serializer = serializer(result_page,
embed=True,
many=True)
return paginator.get_paginated_response(
{"resources": resource_type_serializer.data})
except Exception as e:
return Response(status=status.HTTP_500_INTERNAL_SERVER_ERROR,
exception=e)
def get_queryset(self):
"""
Filter users with atleast a resource
"""
queryset = get_user_model().objects.all().exclude(pk=-1)
filter_options = {}
if self.request.query_params:
filter_options = {
'type_filter': self.request.query_params.get('type'),
'title_filter': self.request.query_params.get('title__icontains')
}
queryset = queryset.filter(id__in=Subquery(
get_resources_with_perms(self.request.user, filter_options).values('owner'))
)
return queryset
def filter_queryset(self, request, queryset, view):
# We want to defer this import until runtime, rather than import-time.
# See https://github.com/encode/django-rest-framework/issues/4608
# (Also see #1624 for why we need to make this import explicitly)
user = request.user
# perm_format = '%(app_label)s.view_%(model_name)s'
# permission = self.perm_format % {
# 'app_label': queryset.model._meta.app_label,
# 'model_name': queryset.model._meta.model_name,
# }
obj_with_perms = get_resources_with_perms(
user, shortcut_kwargs=self.shortcut_kwargs)
logger.debug(f" user: {user} -- obj_with_perms: {obj_with_perms}")
return queryset.filter(id__in=obj_with_perms.values('id'))
def resource_service_exists(request, uuid: str):
"""
Returns a JSON boolean success field valorized with the 'exists' operation outcome.
- GET http://localhost:8000/api/v2/resource-service/exists/13decd74-df04-11eb-a0c1-00155dc3de71
```
200,
{
'success': true
}
```
"""
_exists = False
if resource_manager.exists(uuid):
_exists = get_resources_with_perms(
request.user).filter(uuid=uuid).exists()
return Response({'success': _exists}, status=status.HTTP_200_OK)
def resource_types(self, request):
resource_types = []
_types = []
for _model in apps.get_models():
if _model.__name__ == "ResourceBase":
for _m in _model.__subclasses__():
if _m.__name__.lower() not in ['geoapp', 'service']:
_types.append(_m.__name__.lower())
if settings.GEONODE_APPS_ENABLE:
_types.extend(get_geoapp_subtypes())
for _type in _types:
resource_types.append({
"name": _type,
"count": get_resources_with_perms(request.user).filter(resource_type=_type).count()
})
return Response({"resource_types": resource_types})
def to_representation(self, instance):
request = self.context.get('request')
filter_options = {}
if request.query_params:
filter_options = {
'type_filter': request.query_params.get('type'),
'title_filter': request.query_params.get('title__icontains')
}
data = super().to_representation(instance)
if not isinstance(data, int):
try:
count_filter = {self.Meta.count_type: instance}
data['count'] = get_resources_with_perms(
request.user,
filter_options).filter(**count_filter).count()
except (TypeError, NoReverseMatch) as e:
logger.exception(e)
return data
