OpenConceptLab/ocl_online#56 | Add user content activity summary endpoint

Author: snyaggarwal

core/users/serializers.py

@@ -266,3 +266,16 @@ def update(self, instance, validated_data):
         if instance.id:
             instance.set_checksums()
         return instance
+
+
+class UserContentSummarySerializer(serializers.Serializer):  # pylint: disable=abstract-method
+    username = serializers.CharField(read_only=True)
+    concepts_created = IntegerField(read_only=True)
+    concepts_updated = IntegerField(read_only=True)
+    mappings_created = IntegerField(read_only=True)
+    mappings_updated = IntegerField(read_only=True)
+    sources_owned = IntegerField(read_only=True)
+    collections_owned = IntegerField(read_only=True)
+    references_added = IntegerField(read_only=True)
+    versions_created = IntegerField(read_only=True)
+    expansions_created = IntegerField(read_only=True)

core/users/tests/tests.py

@@ -382,3 +382,80 @@ def test_send_user_reset_password_email(self, send_mail_mock):
         self.assertTrue(user.reset_password_url in mail.body)
         self.assertTrue(f'Hi {user.username},' in mail.body)
         send_mail_mock.assert_called_once()
+
+
+class UserContentSummaryViewTest(OCLAPITestCase):
+    def setUp(self):
+        super().setUp()
+        self.user = UserProfileFactory(username='summaryuser')
+        self.token = self.user.get_token()
+
+    def test_unauthenticated(self):
+        response = self.client.get('/users/summaryuser/content-summary/')
+        self.assertEqual(response.status_code, 401)
+
+    def test_self_user(self):
+        response = self.client.get(
+            '/users/summaryuser/content-summary/',
+            HTTP_AUTHORIZATION='Token ' + self.token,
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data['username'], 'summaryuser')
+        self.assertEqual(response.data['concepts_created'], 0)
+        self.assertEqual(response.data['concepts_updated'], 0)
+        self.assertEqual(response.data['mappings_created'], 0)
+        self.assertEqual(response.data['mappings_updated'], 0)
+        self.assertEqual(response.data['sources_owned'], 0)
+        self.assertEqual(response.data['collections_owned'], 0)
+        self.assertEqual(response.data['references_added'], 0)
+        self.assertEqual(response.data['versions_created'], 0)
+        self.assertEqual(response.data['expansions_created'], 0)
+
+    def test_other_user_forbidden(self):
+        other_user = UserProfileFactory(username='otheruser')
+        other_token = other_user.get_token()
+
+        response = self.client.get(
+            '/users/summaryuser/content-summary/',
+            HTTP_AUTHORIZATION='Token ' + other_token,
+        )
+        self.assertEqual(response.status_code, 403)
+
+    def test_staff_can_view_other_user(self):
+        admin = UserProfileFactory(username='adminuser', is_staff=True)
+        admin_token = admin.get_token()
+
+        response = self.client.get(
+            '/users/summaryuser/content-summary/',
+            HTTP_AUTHORIZATION='Token ' + admin_token,
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data['username'], 'summaryuser')
+
+    def test_nonexistent_user(self):
+        response = self.client.get(
+            '/users/doesnotexist/content-summary/',
+            HTTP_AUTHORIZATION='Token ' + self.token,
+        )
+        self.assertEqual(response.status_code, 404)
+
+    def test_with_content(self):
+        from core.sources.tests.factories import UserSourceFactory
+        from core.concepts.tests.factories import ConceptFactory
+        from core.mappings.tests.factories import MappingFactory
+        from core.collections.tests.factories import UserCollectionFactory
+
+        source = UserSourceFactory(user=self.user, created_by=self.user)
+        ConceptFactory(parent=source, created_by=self.user, updated_by=self.user)
+        MappingFactory(parent=source, created_by=self.user, updated_by=self.user)
+        UserCollectionFactory(user=self.user, created_by=self.user)
+
+        response = self.client.get(
+            '/users/summaryuser/content-summary/',
+            HTTP_AUTHORIZATION='Token ' + self.token,
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data['sources_owned'], 1)
+        self.assertEqual(response.data['collections_owned'], 1)
+        self.assertGreaterEqual(response.data['concepts_created'], 1)
+        self.assertGreaterEqual(response.data['mappings_created'], 1)

core/users/urls.py

@@ -29,6 +29,7 @@
     path('<str:user>/following/<int:id>/', views.UserFollowingView.as_view(), name='userprofile-following'),
     path('<str:user>/orgs/', org_views.OrganizationListView.as_view(), name='userprofile-orgs'),
     path('<str:user>/extras/', views.UserExtrasView.as_view(), name='user-extras'),
+    path('<str:user>/content-summary/', views.UserContentSummaryView.as_view(), name='user-content-summary'),
     path(
         '<str:user>/orgs/sources/',
         org_views.OrganizationSourceListView.as_view(), name='userprofile-organization-source-list'),

core/users/views.py

@@ -19,7 +19,7 @@
 from rest_framework.views import APIView
 
 from core.common.constants import NOT_FOUND, MUST_SPECIFY_EXTRA_PARAM_IN_BODY, LAST_LOGIN_SINCE_PARAM, \
-    LAST_LOGIN_BEFORE_PARAM, DATE_JOINED_SINCE_PARAM, DATE_JOINED_BEFORE_PARAM, UPDATED_BY_USERNAME_PARAM
+    LAST_LOGIN_BEFORE_PARAM, DATE_JOINED_SINCE_PARAM, DATE_JOINED_BEFORE_PARAM, UPDATED_BY_USERNAME_PARAM, HEAD
 from core.common.exceptions import Http400
 from core.common.mixins import ListWithHeadersMixin
 from core.common.swagger_parameters import last_login_before_param, last_login_since_param, updated_since_param, \
@@ -34,7 +34,7 @@
 from core.users.documents import UserProfileDocument
 from core.users.search import UserProfileFacetedSearch
 from core.users.serializers import UserDetailSerializer, UserCreateSerializer, UserListSerializer, \
-    UserSummarySerializer, FollowingSerializer
+    UserSummarySerializer, FollowingSerializer, UserContentSummarySerializer
 from .models import UserProfile, Follow
 from ..common import ERRBIT_LOGGER
 from ..common.throttling import ThrottleUtil
@@ -624,3 +624,51 @@ def perform_destroy(self, instance):
         follower.unfollow(instance.following)
 
         return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class UserContentSummaryView(APIView):
+    permission_classes = (IsAuthenticated,)
+    serializer_class = UserContentSummarySerializer
+
+    def get(self, request, user):
+        from django.db.models import F
+        from core.collections.models import Collection, CollectionReference, Expansion
+        from core.concepts.models import Concept
+        from core.mappings.models import Mapping
+        from core.sources.models import Source
+
+        try:
+            profile = UserProfile.objects.get(username=user)
+        except UserProfile.DoesNotExist:
+            return Response(status=status.HTTP_404_NOT_FOUND)
+
+        is_self = request.user.username == profile.username
+        if not is_self and not request.user.is_staff:
+            raise PermissionDenied()
+
+        head_concepts = Concept.objects.filter(id=F('versioned_object_id'))
+        head_mappings = Mapping.objects.filter(id=F('versioned_object_id'))
+        user_head_sources = Source.objects.filter(user=profile, version=HEAD)
+        user_head_collections = Collection.objects.filter(user=profile, version=HEAD)
+
+        # Non-HEAD versions created by this user (version releases)
+        user_source_versions = Source.objects.filter(
+            created_by=profile).exclude(version=HEAD)
+        user_collection_versions = Collection.objects.filter(
+            created_by=profile).exclude(version=HEAD)
+
+        data = {
+            'username': profile.username,
+            'concepts_created': head_concepts.filter(created_by=profile).count(),
+            'concepts_updated': head_concepts.filter(updated_by=profile).count(),
+            'mappings_created': head_mappings.filter(created_by=profile).count(),
+            'mappings_updated': head_mappings.filter(updated_by=profile).count(),
+            'sources_owned': user_head_sources.count(),
+            'collections_owned': user_head_collections.count(),
+            'references_added': CollectionReference.objects.filter(
+                collection__in=user_head_collections, created_by=profile).count(),
+            'versions_created': user_source_versions.count() + user_collection_versions.count(),
+            'expansions_created': Expansion.objects.filter(created_by=profile).count(),
+        }
+        serializer = self.serializer_class(data)
+        return Response(serializer.data)