zalf-rdm
diff --git a/‎geonode/api/api.py
+37-4 b/‎geonode/api/api.py
+37-4
diff --git a/‎geonode/api/resourcebase_api.py
+66 b/‎geonode/api/resourcebase_api.py
+66
diff --git a/‎geonode/api/urls.py
+1 b/‎geonode/api/urls.py
+1
diff --git a/‎geonode/base/api/serializers.py
+8 b/‎geonode/base/api/serializers.py
+8
diff --git a/‎geonode/base/api/tests.py
+60-4 b/‎geonode/base/api/tests.py
+60-4
diff --git a/‎geonode/base/api/urls.py
+1-1 b/‎geonode/base/api/urls.py
+1-1
diff --git a/‎geonode/base/api/views.py
+68-1 b/‎geonode/base/api/views.py
+68-1
@@ -21,6 +21,7 @@
 import json
 import time
 
+from django.apps import apps
 from django.db.models import Q
 from django.conf.urls import url
 from django.contrib.auth import get_user_model
@@ -52,6 +53,7 @@
 from geonode.base.models import ThesaurusKeywordLabel
 from geonode.layers.models import Layer, Style
 from geonode.maps.models import Map
+from geonode.geoapps.models import GeoApp
 from geonode.documents.models import Document
 from geonode.groups.models import GroupProfile, GroupCategory
 from django.core.serializers.json import DjangoJSONEncoder
@@ -67,7 +69,8 @@
 FILTER_TYPES = {
     'layer': Layer,
     'map': Map,
-    'document': Document
+    'document': Document,
+    'geoapp': GeoApp
 }
 
 
@@ -90,19 +93,37 @@ def get_resources_counts(self, options):
             unpublished_not_visible=settings.RESOURCE_PUBLISHING,
             private_groups_not_visibile=settings.GROUP_PRIVATE_RESOURCES)
 
+        subtypes = []
         if resources and resources.count() > 0:
             if options['title_filter']:
                 resources = resources.filter(title__icontains=options['title_filter'])
-
             if options['type_filter']:
                 _type_filter = options['type_filter']
+
+                for label, app in apps.app_configs.items():
+                    if hasattr(app, 'type') and app.type == 'GEONODE_APP':
+                        if hasattr(app, 'default_model'):
+                            _model = apps.get_model(label, app.default_model)
+                            if issubclass(_model, _type_filter):
+                                subtypes.append(
+                                    resources.filter(
+                                        polymorphic_ctype__model=_model.__name__.lower()))
+
                 if not isinstance(_type_filter, str):
                     _type_filter = _type_filter.__name__.lower()
                 resources = resources.filter(polymorphic_ctype__model=_type_filter)
 
-        counts = list(resources.values(options['count_type']).annotate(count=Count(options['count_type'])))
+        counts = list()
+        if subtypes:
+            for subtype in subtypes:
+                counts.append(
+                    subtype.values(options['count_type']).annotate(count=Count(options['count_type'])).first()
+                )
+        else:
+            counts = list(resources.values(options['count_type']).annotate(count=Count(options['count_type'])))
 
-        return dict([(c[options['count_type']], c['count']) for c in counts])
+        return dict(
+            [(c[options['count_type']], c['count']) for c in counts if c and c['count'] and options['count_type']])
 
     def to_json(self, data, options=None):
         options = options or {}
@@ -869,8 +890,18 @@ def _get_resource_counts(request, resourcebase_filter_kwargs):
         'layer',
         'document',
         'map',
+        'geoapp',
         'all'
     ]
+
+    subtypes = []
+    for label, app in apps.app_configs.items():
+        if hasattr(app, 'type') and app.type == 'GEONODE_APP':
+            if hasattr(app, 'default_model'):
+                _model = apps.get_model(label, app.default_model)
+                if issubclass(_model, GeoApp):
+                    types.append(_model.__name__.lower())
+                    subtypes.append(_model.__name__.lower())
     counts = {}
     for type_ in types:
         counts[type_] = {
@@ -881,6 +912,8 @@ def _get_resource_counts(request, resourcebase_filter_kwargs):
         }
     for record in qs:
         resource_type = record['polymorphic_ctype__model']
+        if resource_type in subtypes:
+            resource_type = 'geoapp'
         is_visible = all((record['is_approved'], record['is_published']))
         counts['all']['total'] += record['counts']
         counts['all']['visible'] += record['counts'] if is_visible else 0
 
@@ -49,6 +49,7 @@
 from geonode import get_version, qgis_server, geoserver
 from geonode.layers.models import Layer
 from geonode.maps.models import Map
+from geonode.geoapps.models import GeoApp
 from geonode.documents.models import Document
 from geonode.base.models import ResourceBase
 from geonode.base.models import HierarchicalKeyword
@@ -165,6 +166,8 @@ def build_filters(self, filters=None, ignore_bad_filters=False, **kwargs):
             filters=filters, ignore_bad_filters=ignore_bad_filters, **kwargs)
         if 'type__in' in filters and filters['type__in'] in FILTER_TYPES.keys():
             orm_filters.update({'type': filters.getlist('type__in')})
+        if 'app_type__in' in filters:
+            orm_filters.update({'polymorphic_ctype__model': filters['app_type__in'].lower()})
         if 'extent' in filters:
             orm_filters.update({'extent': filters['extent']})
         orm_filters['f_method'] = filters['f_method'] if 'f_method' in filters else 'and'
@@ -1016,6 +1019,69 @@ class Meta(CommonMetaApi):
                                              GeonodeApiKeyAuthentication())
 
 
+class GeoAppResource(CommonModelApi):
+
+    """GeoApps API"""
+
+    def format_objects(self, objects):
+        """
+        Formats the objects and provides reference to list of layers in GeoApp
+        resources.
+
+        :param objects: GeoApp objects
+        """
+        formatted_objects = []
+        for obj in objects:
+            # convert the object to a dict using the standard values.
+            formatted_obj = model_to_dict(obj, fields=self.VALUES)
+            username = obj.owner.get_username()
+            full_name = (obj.owner.get_full_name() or username)
+            formatted_obj['owner__username'] = username
+            formatted_obj['owner_name'] = full_name
+            if obj.category:
+                formatted_obj['category__gn_description'] = obj.category.gn_description
+            if obj.group:
+                formatted_obj['group'] = obj.group
+                try:
+                    formatted_obj['group_name'] = GroupProfile.objects.get(slug=obj.group.name)
+                except GroupProfile.DoesNotExist:
+                    formatted_obj['group_name'] = obj.group
+
+            formatted_obj['keywords'] = [k.name for k in obj.keywords.all()] if obj.keywords else []
+            formatted_obj['regions'] = [r.name for r in obj.regions.all()] if obj.regions else []
+
+            if 'site_url' not in formatted_obj or len(formatted_obj['site_url']) == 0:
+                formatted_obj['site_url'] = settings.SITEURL
+
+            # Probe Remote Services
+            formatted_obj['store_type'] = 'geoapp'
+            formatted_obj['online'] = True
+
+            # replace thumbnail_url with curated_thumbs
+            try:
+                if hasattr(obj, 'curatedthumbnail'):
+                    if hasattr(obj.curatedthumbnail.img_thumbnail, 'url'):
+                        formatted_obj['thumbnail_url'] = obj.curatedthumbnail.thumbnail_url
+                    else:
+                        formatted_obj['thumbnail_url'] = ''
+            except Exception as e:
+                formatted_obj['thumbnail_url'] = ''
+                logger.exception(e)
+
+            formatted_objects.append(formatted_obj)
+        return formatted_objects
+
+    class Meta(CommonMetaApi):
+        paginator_class = CrossSiteXHRPaginator
+        filtering = CommonMetaApi.filtering
+        filtering.update({'app_type': ALL})
+        queryset = GeoApp.objects.distinct().order_by('-date')
+        resource_name = 'geoapps'
+        authentication = MultiAuthentication(SessionAuthentication(),
+                                             OAuthAuthentication(),
+                                             GeonodeApiKeyAuthentication())
+
+
 class DocumentResource(CommonModelApi):
 
     """Documents API"""
 
@@ -46,6 +46,7 @@
 api.register(resourcebase_resources.FeaturedResourceBaseResource())
 api.register(resourcebase_resources.LayerResource())
 api.register(resourcebase_resources.MapResource())
+api.register(resourcebase_resources.GeoAppResource())
 api.register(resourcebase_resources.ResourceBaseResource())
 
 router = routers.DynamicRouter()
 
@@ -44,6 +44,14 @@
 logger = logging.getLogger(__name__)
 
 
+class ResourceBaseTypesSerializer(DynamicEphemeralSerializer):
+
+    class Meta:
+        name = 'resource-type'
+
+    resource_types = serializers.ListField()
+
+
 class PermSpecSerialiazer(DynamicEphemeralSerializer):
 
     class Meta:
 
@@ -197,7 +197,11 @@ def test_base_resources(self):
         # Pagination
         self.assertEqual(len(response.data['resources']), 17)
 
-        # Search
+    def test_search_resources(self):
+        """
+        Ensure we can search across the Resource Base list.
+        """
+        url = reverse('base-resources-list')
         # Admin
         self.assertTrue(self.client.login(username='admin', password='admin'))
 
@@ -209,7 +213,11 @@ def test_base_resources(self):
         # Pagination
         self.assertEqual(len(response.data['resources']), 1)
 
-        # Filtering
+    def test_filter_resources(self):
+        """
+        Ensure we can filter across the Resource Base list.
+        """
+        url = reverse('base-resources-list')
         # Admin
         self.assertTrue(self.client.login(username='admin', password='admin'))
 
@@ -297,7 +305,11 @@ def test_base_resources(self):
         # Pagination
         self.assertEqual(len(response.data['resources']), 12)
 
-        # Sorting
+    def test_sort_resources(self):
+        """
+        Ensure we can sort the Resource Base list.
+        """
+        url = reverse('base-resources-list')
         # Admin
         self.assertTrue(self.client.login(username='admin', password='admin'))
 
@@ -330,7 +342,11 @@ def test_base_resources(self):
         reversed_resource_titles = sorted(resource_titles.copy())
         self.assertNotEqual(resource_titles, reversed_resource_titles)
 
-        # Get & Set Permissions
+    def test_perms_resources(self):
+        """
+        Ensure we can Get & Set Permissions across the Resource Base list.
+        """
+        url = reverse('base-resources-list')
         # Admin
         self.assertTrue(self.client.login(username='admin', password='admin'))
 
@@ -371,3 +387,43 @@ def test_base_resources(self):
         self.assertEqual(response.status_code, 200)
         resource_perm_spec = response.data
         self.assertFalse('norman' in resource_perm_spec['users'])
+
+    def test_featured_and_published_resources(self):
+        """
+        Ensure we can Get & Set Permissions across the Resource Base list.
+        """
+        url = reverse('base-resources-list')
+        # Admin
+        self.assertTrue(self.client.login(username='admin', password='admin'))
+
+        resources = ResourceBase.objects.filter(owner__username='bobby')
+
+        url = urljoin(f"{reverse('base-resources-list')}/", 'featured/')
+        response = self.client.get(url, format='json')
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(len(response.data), 5)
+        self.assertEqual(response.data['total'], 0)
+        # Pagination
+        self.assertEqual(len(response.data['resources']), 0)
+
+        resources.filter(resource_type='map').update(featured=True)
+        url = urljoin(f"{reverse('base-resources-list')}/", 'featured/')
+        response = self.client.get(url, format='json')
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(len(response.data), 5)
+        self.assertEqual(response.data['total'], 2)
+        # Pagination
+        self.assertEqual(len(response.data['resources']), 2)
+
+    def test_resource_types(self):
+        """
+        Ensure we can Get & Set Permissions across the Resource Base list.
+        """
+        url = urljoin(f"{reverse('base-resources-list')}/", 'resource_types/')
+        response = self.client.get(url, format='json')
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue('resource_types' in response.data)
+        self.assertTrue('layer' in response.data['resource_types'])
+        self.assertTrue('map' in response.data['resource_types'])
+        self.assertTrue('document' in response.data['resource_types'])
+        self.assertTrue('service' in response.data['resource_types'])
@@ -23,6 +23,6 @@
 
 router.register(r'users', views.UserViewSet, 'users')
 router.register(r'groups', views.GroupViewSet, 'group-profiles')
-router.register(r'base_resources', views.ResourceBaseViewSet, 'base-resources')
+router.register(r'resources', views.ResourceBaseViewSet, 'base-resources')
 
 urlpatterns = []
@@ -17,6 +17,7 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
 #########################################################################
+from django.apps import apps
 from django.conf import settings
 from django.contrib.auth import get_user_model
 
@@ -45,7 +46,8 @@
     UserSerializer,
     PermSpecSerialiazer,
     GroupProfileSerializer,
-    ResourceBaseSerializer
+    ResourceBaseSerializer,
+    ResourceBaseTypesSerializer
 )
 from .pagination import GeoNodeApiPagination
 
@@ -145,6 +147,71 @@ class ResourceBaseViewSet(DynamicModelViewSet):
     serializer_class = ResourceBaseSerializer
     pagination_class = GeoNodeApiPagination
 
+    def _filtered(self, request, filter):
+        paginator = GeoNodeApiPagination()
+        paginator.page_size = request.GET.get('page_size', 10)
+        resources = ResourceBase.objects.filter(**filter)
+        exclude = []
+        for resource in resources:
+            if not request.user.is_superuser and \
+            not request.user.has_perm('view_resourcebase', resource.get_self_resource()):
+                exclude.append(resource.id)
+        resources = resources.exclude(id__in=exclude)
+        result_page = paginator.paginate_queryset(resources, request)
+        serializer = ResourceBaseSerializer(result_page, embed=True, many=True)
+        return paginator.get_paginated_response({"resources": serializer.data})
+
+    @extend_schema(methods=['get'], responses={200: ResourceBaseSerializer(many=True)},
+                   description="API endpoint allowing to retrieve the approved Resources.")
+    @action(detail=False, methods=['get'])
+    def approved(self, request):
+        return self._filtered(request, {"is_approved": True})
+
+    @extend_schema(methods=['get'], responses={200: ResourceBaseSerializer(many=True)},
+                   description="API endpoint allowing to retrieve the published Resources.")
+    @action(detail=False, methods=['get'])
+    def published(self, request):
+        return self._filtered(request, {"is_published": True})
+
+    @extend_schema(methods=['get'], responses={200: ResourceBaseSerializer(many=True)},
+                   description="API endpoint allowing to retrieve the featured Resources.")
+    @action(detail=False, methods=['get'])
+    def featured(self, request):
+        return self._filtered(request, {"featured": True})
+
+    @extend_schema(methods=['get'], responses={200: ResourceBaseTypesSerializer()},
+                   description="""
+        Returns the list of available ResourceBase polymorphic_ctypes.
+
+        the mapping looks like:
+        ```
+        {
+            "resource_types": [
+                "layer",
+                "map",
+                "document",
+                "service"
+            ]
+        }
+        ```
+        """)
+    @action(detail=False, methods=['get'])
+    def resource_types(self, request):
+        resource_types = []
+        for _model in apps.get_models():
+            if _model.__name__ == "ResourceBase":
+                resource_types = [_m.__name__.lower() for _m in _model.__subclasses__()]
+        if "geoapp" in resource_types:
+            from geonode.geoapps.models import GeoApp
+            resource_types.remove("geoapp")
+            for label, app in apps.app_configs.items():
+                if hasattr(app, 'type') and app.type == 'GEONODE_APP':
+                    if hasattr(app, 'default_model'):
+                        _model = apps.get_model(label, app.default_model)
+                        if issubclass(_model, GeoApp):
+                            resource_types.append(_model.__name__.lower())
+        return Response({"resource_types": resource_types})
+
     @extend_schema(methods=['get'], responses={200: PermSpecSerialiazer()},
                    description="""
         Gets an object's the permission levels based on the perm_spec JSON.