edx-enterprise-data 8.11.1__py3-none-any.whl → 8.12.1__py3-none-any.whl

{edx_enterprise_data-8.11.1.dist-info → edx_enterprise_data-8.12.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: edx-enterprise-data
-Version: 8.11.1
+Version: 8.12.1
 Summary: Enterprise Reporting
 Home-page: https://github.com/openedx/edx-enterprise-data
 Author: edX

{edx_enterprise_data-8.11.1.dist-info → edx_enterprise_data-8.12.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-enterprise_data/__init__.py,sha256=XT15XKKqKMAKtb0mKrGHjwWzDy3Y_AMCd_U5UKSh5Rc,124
+enterprise_data/__init__.py,sha256=8TjCXGqGwt4y6eG7nZC6OYCp9Dut66Hr_TTySgVt3PE,124
 enterprise_data/apps.py,sha256=aF6hZwDfI2oWj95tUTm_2ikHueQj-jLj-u0GrgzpsQI,414
 enterprise_data/clients.py,sha256=GvQupy5TVYfO_IKC3yzXSAgNP54r-PtIjidM5ws9Iks,3947
 enterprise_data/constants.py,sha256=uCKjfpdlMYFZJsAj3n9RMw4Cmg5_6s3NuwocO-fch3s,238
@@ -15,14 +15,14 @@ enterprise_data/admin_analytics/constants.py,sha256=7WturLuMISekgcHHlgj45PPdPrDT
 enterprise_data/admin_analytics/data_loaders.py,sha256=4PSsIveNBtpFqwrLUjTl5oywHVYFAMdZrNRHRGMk4XY,6116
 enterprise_data/admin_analytics/utils.py,sha256=CQuTlg36AALJiopp4us-JN8oTXsw-jDXSJenbphLDME,12270
 enterprise_data/admin_analytics/database/__init__.py,sha256=vNSWKf2VV5xMegN7htJJtxtQEb0ASLC6frE2w0ZpYpE,104
-enterprise_data/admin_analytics/database/utils.py,sha256=Zl-W_w5SVb-QpIwWxbHr0w7z4L2ZFeruJSygWh8g7II,1408
+enterprise_data/admin_analytics/database/utils.py,sha256=5u-d6ZQW95mF_r4bH8Xdi7DgpYAuDFOG_q0P-bjKXHU,1712
 enterprise_data/admin_analytics/database/queries/__init__.py,sha256=IC5TLOr_GnydbrVbl2mWhwO3aUbYeHuDmfPTLmwGhZA,218
 enterprise_data/admin_analytics/database/queries/fact_engagement_admin_dash.py,sha256=fq01Ni_sKnvSRoiPQfTnJ8TtRePQe5MBLmI5CpVy36o,747
-enterprise_data/admin_analytics/database/queries/fact_enrollment_admin_dash.py,sha256=X1muOEhEvqD-tyhrVEQkPrf8_7g7SPaJuMwriUPo3jw,2062
+enterprise_data/admin_analytics/database/queries/fact_enrollment_admin_dash.py,sha256=uuhX3OIB5Cp0-5uxN604HNEUuzb3s9nH3VR4CiEXs18,5388
 enterprise_data/admin_analytics/database/tables/__init__.py,sha256=3ECKlKlz1wuTER5M57CMFvmLFp0oCnVQXAUeTN96Bs0,213
 enterprise_data/admin_analytics/database/tables/base.py,sha256=1KyKsC18pW3m-5U-T6pdt5rIwsz6Wp3QFFbD3r6L6YQ,395
 enterprise_data/admin_analytics/database/tables/fact_engagement_admin_dash.py,sha256=EsG8KgRW84wtA_nJuUknjLYlDtaPSJf_9mWdkO2Bj2I,1293
-enterprise_data/admin_analytics/database/tables/fact_enrollment_admin_dash.py,sha256=WiFWVF4TsDhLlDQr-3FuqTrzFy7Qv1Y5EnwZXYhdTrM,2962
+enterprise_data/admin_analytics/database/tables/fact_enrollment_admin_dash.py,sha256=ix5QvPnrUZMVs_Fdt742i9PAmrQTXuqHlfW3PJhSQWo,7282
 enterprise_data/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 enterprise_data/api/urls.py,sha256=POqc_KATHdnpMf9zHtpO46pKD5KAlAExtx7G6iylLcU,273
 enterprise_data/api/v0/__init__.py,sha256=1aAzAYU5hk-RW6cKUxa1645cbZMxn7GIZ7OMjWc9MKI,46
@@ -31,13 +31,13 @@ enterprise_data/api/v0/urls.py,sha256=vzJjqIo_S3AXWs9Us8XTaJc3FnxLbYzAkmLyuDQqum
 enterprise_data/api/v0/views.py,sha256=4RslZ4NZOU-844bnebEQ71ji2utRY7jEijqC45oQQD0,14380
 enterprise_data/api/v1/__init__.py,sha256=1aAzAYU5hk-RW6cKUxa1645cbZMxn7GIZ7OMjWc9MKI,46
 enterprise_data/api/v1/paginators.py,sha256=f0xsilLaU94jSBltJk46tR1rLEIt7YrqSzMAAVtPXjA,3592
-enterprise_data/api/v1/serializers.py,sha256=Kk4zuRNcr4bfMYIwi2iXQAr_NM3OXuXNfxfrz7xO2iE,13194
-enterprise_data/api/v1/urls.py,sha256=nFcbPSfAIKW6Eiwd1vN0WMqdtBfh9_bBqAFCVrzRm5I,4091
+enterprise_data/api/v1/serializers.py,sha256=FEuH-_iTlKFJoxM8ABzEYHDAWHsgSYfdQd2WSPdXoeE,13329
+enterprise_data/api/v1/urls.py,sha256=JzaaVsHEAELMLFdhR60_8LRLb9klDeA4zdH1dLxnQEo,4048
 enterprise_data/api/v1/views/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 enterprise_data/api/v1/views/analytics_engagements.py,sha256=8H3Fk-hTqJaU3H5Lpu1kFWq7p7xDp1pjge-sK7osDbg,17553
-enterprise_data/api/v1/views/analytics_enrollments.py,sha256=trC92GOej6vUoju53KT3dPEDnoPHdukfXEIXPThz76A,16886
+enterprise_data/api/v1/views/analytics_enrollments.py,sha256=uVc36C0s9y1dPBfbYwFhXLqPlExvQvZeiJ4C45lb4ZQ,6447
 enterprise_data/api/v1/views/analytics_leaderboard.py,sha256=2DALqzUIbe4-ZGgHHIkYAKJ5L1ik2ruPtQNYtTdPba4,5974
-enterprise_data/api/v1/views/base.py,sha256=FTAxlz5EzvAY657wzVgzhJPFSCHHzct7IDcvm71Smt8,866
+enterprise_data/api/v1/views/base.py,sha256=Kkmd5zgEBAhvwS_GoGXSK6lgbDNwSPioYn-QbnizI3w,3416
 enterprise_data/api/v1/views/enterprise_admin.py,sha256=d79WkyBbqLk6pKGWWrnbYdrbOgQztP03Q7NKRA5tZB4,8639
 enterprise_data/api/v1/views/enterprise_completions.py,sha256=bJG2ZtTbLyiBrj64iJHQNHEKLrJCzl9OuJ7nDtw-9aY,8377
 enterprise_data/api/v1/views/enterprise_learner.py,sha256=yABjJje3CT8I8YOhWr1_tTkdKtnGJom8eu3EFz_-0BU,18517
@@ -113,10 +113,10 @@ enterprise_data/tests/test_models.py,sha256=MWBY-LY5TPBjZ4GlvpM-h4W-BvRKr2Rml8Bz
 enterprise_data/tests/test_utils.py,sha256=vbmYM7DMN-lHS2p4yaa0Yd6uSGXd2qoZRDE9X3J4Sec,18385
 enterprise_data/tests/test_views.py,sha256=UvDRNTxruy5zBK_KgUy2cBMbwlaTW_vkM0-TCXbQZiY,69667
 enterprise_data/tests/admin_analytics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-enterprise_data/tests/admin_analytics/mock_analytics_data.py,sha256=LoYAh5cn_4rv2stGcMP5PELv2l7Eu2DTKG-v7viNTCs,20266
+enterprise_data/tests/admin_analytics/mock_analytics_data.py,sha256=VZHhMKSQn5S-o1wNReSVyEnI_-6EkW-TUV5EvXCl5is,19536
 enterprise_data/tests/admin_analytics/mock_enrollments.py,sha256=LfuMo9Kn-OQD4z42G3BRuM5MXUUXXlaAMhTqfJf46XE,7266
 enterprise_data/tests/admin_analytics/test_analytics_engagements.py,sha256=KPXtBPaAOrzfff7W-xERSGx9KtZAJndLbIJx3gopSnE,15689
-enterprise_data/tests/admin_analytics/test_analytics_enrollments.py,sha256=UdKRkP6BNbsSo-gm0YCoddT-ReUMI1x9E6HNLSHT7pY,15177
+enterprise_data/tests/admin_analytics/test_analytics_enrollments.py,sha256=GePv5E8BRGRWUHUwGaXvYIsN3dtDpNXUh-yfW5iBTi4,13781
 enterprise_data/tests/admin_analytics/test_analytics_leaderboard.py,sha256=VSEyDAHfWBJvqmx9yzd4NnPAqK3TqaKrMBWswMAdzfU,6206
 enterprise_data/tests/admin_analytics/test_data_loaders.py,sha256=o3denJ4aUS1pI5Crksl4C6m-NtCBm8ynoHBnLkf-v2U,4641
 enterprise_data/tests/admin_analytics/test_enterprise_completions.py,sha256=afkHQFy4bvqZ0pq5Drl1t2nv8zxbgca2jzOQbihlPG0,7359
@@ -169,8 +169,8 @@ enterprise_reporting/tests/test_send_enterprise_reports.py,sha256=WtL-RqGgu2x5PP
 enterprise_reporting/tests/test_utils.py,sha256=Zt_TA0LVb-B6fQGkUkAKKVlUKKnQh8jnw1US1jKe7g8,9493
 enterprise_reporting/tests/test_vertica_client.py,sha256=-R2yNCGUjRtoXwLMBloVFQkFYrJoo613VCr61gwI3kQ,140
 enterprise_reporting/tests/utils.py,sha256=xms2LM7DV3wczXEfctOK1ddel1EE0J_YSr17UzbCDy4,1401
-edx_enterprise_data-8.11.1.dist-info/LICENSE,sha256=dql8h4yceoMhuzlcK0TT_i-NgTFNIZsgE47Q4t3dUYI,34520
-edx_enterprise_data-8.11.1.dist-info/METADATA,sha256=27UVJwZuQylIJzEZ-R-VWbzisk0jOxS04oHJNrjLQTw,1570
-edx_enterprise_data-8.11.1.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-edx_enterprise_data-8.11.1.dist-info/top_level.txt,sha256=f5F2kU-dob6MqiHJpgZkFzoCD5VMhsdpkTV5n9Tvq3I,59
-edx_enterprise_data-8.11.1.dist-info/RECORD,,
+edx_enterprise_data-8.12.1.dist-info/LICENSE,sha256=dql8h4yceoMhuzlcK0TT_i-NgTFNIZsgE47Q4t3dUYI,34520
+edx_enterprise_data-8.12.1.dist-info/METADATA,sha256=zAJ9YvmaCGHDChLF25Cf1zmK3Okmbq3qIG7UJ6E7xuw,1570
+edx_enterprise_data-8.12.1.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+edx_enterprise_data-8.12.1.dist-info/top_level.txt,sha256=f5F2kU-dob6MqiHJpgZkFzoCD5VMhsdpkTV5n9Tvq3I,59
+edx_enterprise_data-8.12.1.dist-info/RECORD,,

enterprise_data/__init__.py

@@ -2,4 +2,4 @@
 Enterprise data api application. This Django app exposes API endpoints used by enterprises.
 """
 
-__version__ = "8.11.1"
+__version__ = "8.12.1"

enterprise_data/admin_analytics/database/queries/fact_enrollment_admin_dash.py

@@ -7,6 +7,30 @@ class FactEnrollmentAdminDashQueries:
     """
     Queries related to the fact_enrollment_admin_dash table.
     """
+    @staticmethod
+    def get_enrollment_count_query():
+        """
+        Get the query to fetch the total number of enrollments for an enterprise customer.
+        """
+        return """
+            SELECT count(*)
+            FROM fact_enrollment_admin_dash
+            WHERE enterprise_customer_uuid=%(enterprise_customer_uuid)s AND
+                enterprise_enrollment_date BETWEEN %(start_date)s AND %(end_date)s;
+        """
+
+    @staticmethod
+    def get_all_enrollments_query():
+        """
+        Get the query to fetch all enrollments.
+        """
+        return """
+            SELECT email, course_title, course_subject, enroll_type, enterprise_enrollment_date
+            FROM fact_enrollment_admin_dash
+            WHERE enterprise_customer_uuid=%(enterprise_customer_uuid)s AND
+                enterprise_enrollment_date BETWEEN %(start_date)s AND %(end_date)s
+            ORDER BY ENTERPRISE_ENROLLMENT_DATE DESC LIMIT %(limit)s OFFSET %(offset)s
+        """
 
     @staticmethod
     def get_enrollment_date_range_query():
@@ -59,3 +83,55 @@ class FactEnrollmentAdminDashQueries:
             WHERE enterprise_customer_uuid=%(enterprise_customer_uuid)s AND
                 activity_date BETWEEN %(start_date)s AND %(end_date)s;
         """
+
+    @staticmethod
+    def get_top_courses_enrollments_query(record_count=20):
+        """
+        Get the query to fetch the enrollment count by courses.
+
+        Query will fetch the top N courses by enrollment count. Where N is the value of record_count.
+
+        Arguments:
+            record_count (int): Number of records to fetch.
+        """
+        # Some local environments raise error when course_title is added in SELECT without GROUP BY.
+        # If you face this issue, you can remove course_title from SELECT.
+        return f"""
+            SELECT course_key, course_title , enroll_type, count(course_key) as enrollment_count
+            FROM fact_enrollment_admin_dash
+            WHERE enterprise_customer_uuid=%(enterprise_customer_uuid)s AND
+                enterprise_enrollment_date BETWEEN %(start_date)s AND %(end_date)s
+            GROUP BY course_key, enroll_type ORDER BY enrollment_count DESC LIMIT {record_count};
+        """
+
+    @staticmethod
+    def get_top_subjects_by_enrollments_query(record_count=20):
+        """
+        Get the query to fetch the enrollment count by subjects.
+
+        Query will fetch the top N subjects by enrollment count. Where N is the value of record_count.
+
+        Arguments:
+            record_count (int): Number of records to fetch.
+        """
+        return f"""
+            SELECT course_subject, enroll_type, count(course_subject) enrollment_count
+            FROM fact_enrollment_admin_dash
+            WHERE enterprise_customer_uuid=%(enterprise_customer_uuid)s AND
+                enterprise_enrollment_date BETWEEN %(start_date)s AND %(end_date)s
+            GROUP BY course_subject, enroll_type ORDER BY enrollment_count DESC LIMIT {record_count};
+        """
+
+    @staticmethod
+    def get_enrolment_time_series_data_query():
+        """
+        Get the query to fetch the enrollment time series data with daily aggregation.
+        """
+        return """
+            SELECT enterprise_enrollment_date, enroll_type, COUNT(*) as enrollment_count
+            FROM fact_enrollment_admin_dash
+            WHERE enterprise_customer_uuid=%(enterprise_customer_uuid)s AND
+                enterprise_enrollment_date BETWEEN %(start_date)s AND %(end_date)s
+            GROUP BY enterprise_enrollment_date, enroll_type
+            ORDER BY enterprise_enrollment_date;
+        """

enterprise_data/admin_analytics/database/tables/fact_enrollment_admin_dash.py

@@ -15,6 +15,56 @@ class FactEnrollmentAdminDashTable(BaseTable):
     """
     queries = FactEnrollmentAdminDashQueries()
 
+    def get_enrollment_count(self, enterprise_customer_uuid: UUID, start_date: date, end_date: date):
+        """
+        Get the total number of enrollments for the given enterprise customer.
+
+        Arguments:
+            enterprise_customer_uuid (UUID): The UUID of the enterprise customer.
+            start_date (date): The start date.
+            end_date (date): The end date.
+
+        Returns:
+            (int): The total number of enrollments.
+        """
+        results = run_query(
+            query=self.queries.get_enrollment_count_query(),
+            params={
+                'enterprise_customer_uuid': enterprise_customer_uuid,
+                'start_date': start_date,
+                'end_date': end_date,
+            }
+        )
+        return results[0][0]
+
+    def get_all_enrollments(
+            self, enterprise_customer_uuid: UUID, start_date: date, end_date: date, limit: int, offset: int
+    ):
+        """
+        Get all enrollments for the given enterprise customer.
+
+        Arguments:
+            enterprise_customer_uuid (UUID): The UUID of the enterprise customer.
+            start_date (date): The start date.
+            end_date (date): The end date.
+            limit (int): The maximum number of records to return.
+            offset (int): The number of records to skip.
+
+        Returns:
+            list<dict>: A list of dictionaries containing the enrollment data.
+        """
+        return run_query(
+            query=self.queries.get_all_enrollments_query(),
+            params={
+                'enterprise_customer_uuid': enterprise_customer_uuid,
+                'start_date': start_date,
+                'end_date': end_date,
+                'limit': limit,
+                'offset': offset,
+            },
+            as_dict=True,
+        )
+
     def get_enrollment_date_range(self, enterprise_customer_uuid: UUID):
         """
         Get the enrollment date range for the given enterprise customer.
@@ -83,3 +133,69 @@ class FactEnrollmentAdminDashTable(BaseTable):
             }
         )
         return results[0][0]
+
+    def get_top_courses_by_enrollments(self, enterprise_customer_uuid: UUID, start_date: date, end_date: date):
+        """
+        Get the top courses enrollments for the given enterprise customer.
+
+        Arguments:
+            enterprise_customer_uuid (UUID): The UUID of the enterprise customer.
+            start_date (date): The start date.
+            end_date (date): The end date.
+
+        Returns:
+            list<dict>: A list of dictionaries containing the course key, course_title and enrollment count.
+        """
+        return run_query(
+            query=self.queries.get_top_courses_enrollments_query(),
+            params={
+                'enterprise_customer_uuid': enterprise_customer_uuid,
+                'start_date': start_date,
+                'end_date': end_date,
+            },
+            as_dict=True,
+        )
+
+    def get_top_subjects_by_enrollments(self, enterprise_customer_uuid: UUID, start_date: date, end_date: date):
+        """
+        Get the top subjects by enrollments for the given enterprise customer.
+
+        Arguments:
+            enterprise_customer_uuid (UUID): The UUID of the enterprise customer.
+            start_date (date): The start date.
+            end_date (date): The end date.
+
+        Returns:
+            list<dict>: A list of dictionaries containing the subject and enrollment count.
+        """
+        return run_query(
+            query=self.queries.get_top_subjects_by_enrollments_query(),
+            params={
+                'enterprise_customer_uuid': enterprise_customer_uuid,
+                'start_date': start_date,
+                'end_date': end_date,
+            },
+            as_dict=True,
+        )
+
+    def get_enrolment_time_series_data(self, enterprise_customer_uuid: UUID, start_date: date, end_date: date):
+        """
+        Get the enrollment time series data for the given enterprise customer.
+
+        Arguments:
+            enterprise_customer_uuid (UUID): The UUID of the enterprise customer.
+            start_date (date): The start date.
+            end_date (date): The end date.
+
+        Returns:
+            list<dict>: A list of dictionaries containing the date and enrollment count.
+        """
+        return run_query(
+            query=self.queries.get_enrolment_time_series_data_query(),
+            params={
+                'enterprise_customer_uuid': enterprise_customer_uuid,
+                'start_date': start_date,
+                'end_date': end_date,
+            },
+            as_dict=True,
+        )

enterprise_data/admin_analytics/database/utils.py

@@ -30,22 +30,27 @@ def get_db_connection(database=settings.ENTERPRISE_REPORTING_DB_ALIAS):
 
 
 @timeit
-def run_query(query, params: dict = None):
+def run_query(query, params: dict = None, as_dict=False):
     """
     Run a query on the database and return the results.
 
     Arguments:
         query (str): The query to run.
         params (dict): The parameters to pass to the query.
+        as_dict (bool): When True, return the results as a dictionary.
 
     Returns:
-        (list): The results of the query.
+        (list | dict): The results of the query.
     """
     try:
         with closing(get_db_connection()) as connection:
             with closing(connection.cursor()) as cursor:
                 cursor.execute(query, params=params)
-                return cursor.fetchall()
+                if as_dict:
+                    columns = [column[0] for column in cursor.description]
+                    return [dict(zip(columns, row)) for row in cursor.fetchall()]
+                else:
+                    return cursor.fetchall()
     except Exception:
         LOGGER.exception(f'[run_query]: run_query failed for query "{query}".')
         raise

enterprise_data/api/v1/serializers.py

@@ -265,6 +265,8 @@ class AdvanceAnalyticsQueryParamSerializer(serializers.Serializer):  # pylint: d
     granularity = serializers.CharField(required=False)
     calculation = serializers.CharField(required=False)
     response_type = serializers.CharField(required=False)
+    page = serializers.IntegerField(required=False, min_value=1)
+    page_size = serializers.IntegerField(required=False, min_value=2)
 
     def validate(self, attrs):
         """

enterprise_data/api/v1/urls.py

@@ -15,10 +15,7 @@ from enterprise_data.api.v1.views.analytics_engagements import (
     AdvanceAnalyticsEngagementStatsView,
     AdvanceAnalyticsIndividualEngagementsView,
 )
-from enterprise_data.api.v1.views.analytics_enrollments import (
-    AdvanceAnalyticsEnrollmentStatsView,
-    AdvanceAnalyticsIndividualEnrollmentsView,
-)
+from enterprise_data.api.v1.views.analytics_enrollments import AdvanceAnalyticsEnrollmentsView
 from enterprise_data.api.v1.views.analytics_leaderboard import AdvanceAnalyticsLeaderboardView
 from enterprise_data.constants import UUID4_REGEX
 
@@ -69,12 +66,12 @@ urlpatterns = [
     ),
     re_path(
         fr'^admin/analytics/(?P<enterprise_uuid>{UUID4_REGEX})/enrollments/stats$',
-        AdvanceAnalyticsEnrollmentStatsView.as_view(),
+        AdvanceAnalyticsEnrollmentsView.as_view({'get': 'stats'}),
         name='enterprise-admin-analytics-enrollments-stats'
     ),
     re_path(
         fr'^admin/analytics/(?P<enterprise_uuid>{UUID4_REGEX})/enrollments$',
-        AdvanceAnalyticsIndividualEnrollmentsView.as_view(),
+        AdvanceAnalyticsEnrollmentsView.as_view({'get': 'list'}),
         name='enterprise-admin-analytics-enrollments'
     ),
     re_path(

enterprise_data/api/v1/views/analytics_enrollments.py

@@ -1,52 +1,74 @@
-"""Advance Analytics for Enrollments"""
+"""
+Advance Analytics for API endpoints to fetch enterprise enrollments data.
+"""
 from datetime import datetime
 from logging import getLogger
 
 from edx_rbac.decorators import permission_required
 from edx_rest_framework_extensions.auth.jwt.authentication import JwtAuthentication
+from rest_framework.decorators import action
 from rest_framework.response import Response
-from rest_framework.views import APIView
+from rest_framework.viewsets import ViewSet
 
-from django.http import HttpResponse, StreamingHttpResponse
+from django.http import StreamingHttpResponse
 
-from enterprise_data.admin_analytics.constants import Calculation, EnrollmentChart, Granularity, ResponseType
-from enterprise_data.admin_analytics.utils import (
-    calculation_aggregation,
-    fetch_and_cache_enrollments_data,
-    fetch_enrollments_cache_expiry_timestamp,
-    granularity_aggregation,
-)
+from enterprise_data.admin_analytics.constants import ResponseType
+from enterprise_data.admin_analytics.database.tables import FactEnrollmentAdminDashTable
 from enterprise_data.api.v1.paginators import AdvanceAnalyticsPagination
 from enterprise_data.api.v1.serializers import (
     AdvanceAnalyticsEnrollmentStatsSerializer,
     AdvanceAnalyticsQueryParamSerializer,
 )
+from enterprise_data.api.v1.views.base import AnalyticsPaginationMixin
 from enterprise_data.renderers import IndividualEnrollmentsCSVRenderer
-from enterprise_data.utils import date_filter, timer
+from enterprise_data.utils import timer
 
 LOGGER = getLogger(__name__)
 
 
-class AdvanceAnalyticsIndividualEnrollmentsView(APIView):
+class AdvanceAnalyticsEnrollmentsView(AnalyticsPaginationMixin, ViewSet):
     """
-    API for getting the advance analytics individual enrollments data.
+    View to handle requests for enterprise enrollments data.
+
+    Here is the list of URLs that are handled by this view:
+    1. `enterprise_data_api_v1.enterprise-learner-enrollment-list`: Get individual enrollment data.
+    2. `enterprise_data_api_v1.enterprise-learner-enrollment-stats`: Get enrollment stats data.
     """
     authentication_classes = (JwtAuthentication,)
     pagination_class = AdvanceAnalyticsPagination
-    http_method_names = ['get']
+    http_method_names = ('get', )
 
     @permission_required('can_access_enterprise', fn=lambda request, enterprise_uuid: enterprise_uuid)
-    def get(self, request, enterprise_uuid):
-        """Get individual enrollments data"""
+    def list(self, request, enterprise_uuid):
+        """
+        Get individual enrollments data for the enterprise.
+        """
+        # Remove hyphens from the UUID
+        enterprise_uuid = enterprise_uuid.replace('-', '')
+
         serializer = AdvanceAnalyticsQueryParamSerializer(data=request.GET)
         serializer.is_valid(raise_exception=True)
-
-        cache_expiry = fetch_enrollments_cache_expiry_timestamp()
-        enrollments_df = fetch_and_cache_enrollments_data(enterprise_uuid, cache_expiry)
+        min_enrollment_date, _ = FactEnrollmentAdminDashTable().get_enrollment_date_range(
+            enterprise_uuid,
+        )
 
         # get values from query params or use default values
-        start_date = serializer.data.get('start_date', enrollments_df.enterprise_enrollment_date.min())
+        start_date = serializer.data.get('start_date', min_enrollment_date)
         end_date = serializer.data.get('end_date', datetime.now())
+        page = serializer.data.get('page', 1)
+        page_size = serializer.data.get('page_size', 100)
+        enrollments = FactEnrollmentAdminDashTable().get_all_enrollments(
+            enterprise_customer_uuid=enterprise_uuid,
+            start_date=start_date,
+            end_date=end_date,
+            limit=page_size,
+            offset=(page - 1) * page_size,
+        )
+        total_count = FactEnrollmentAdminDashTable().get_enrollment_count(
+            enterprise_customer_uuid=enterprise_uuid,
+            start_date=start_date,
+            end_date=end_date,
+        )
         response_type = request.query_params.get('response_type', ResponseType.JSON.value)
 
         LOGGER.info(
@@ -56,333 +78,75 @@ class AdvanceAnalyticsIndividualEnrollmentsView(APIView):
             end_date,
         )
 
-        # filter enrollments by date
-        enrollments = date_filter(start_date, end_date, enrollments_df, "enterprise_enrollment_date")
-
-        # select only the columns that will be in the table.
-        enrollments = enrollments[
-            [
-                "email",
-                "course_title",
-                "course_subject",
-                "enroll_type",
-                "enterprise_enrollment_date",
-            ]
-        ]
-        enrollments["enterprise_enrollment_date"] = enrollments["enterprise_enrollment_date"].dt.date
-        enrollments = enrollments.sort_values(by="enterprise_enrollment_date", ascending=False).reset_index(drop=True)
-
-        LOGGER.info(
-            "Individual enrollments data prepared for enterprise [%s] from [%s] to [%s]",
-            enterprise_uuid,
-            start_date,
-            end_date,
-        )
-
         if response_type == ResponseType.CSV.value:
             filename = f"""individual_enrollments, {start_date} - {end_date}.csv"""
+
             return StreamingHttpResponse(
-                IndividualEnrollmentsCSVRenderer().render(self._stream_serialized_data(enrollments)),
+                IndividualEnrollmentsCSVRenderer().render(self._stream_serialized_data(
+                    enterprise_uuid, start_date, end_date, total_count
+                )),
                 content_type="text/csv",
                 headers={"Content-Disposition": f'attachment; filename="{filename}"'},
             )
 
-        paginator = self.pagination_class()
-        page = paginator.paginate_queryset(enrollments, request)
-        serialized_data = page.data.to_dict(orient='records')
-        response = paginator.get_paginated_response(serialized_data)
-
-        return response
+        return self.get_paginated_response(
+            request=request,
+            records=enrollments,
+            page=page,
+            page_size=page_size,
+            total_count=total_count,
+        )
 
-    def _stream_serialized_data(self, enrollments, chunk_size=50000):
+    @staticmethod
+    def _stream_serialized_data(enterprise_uuid, start_date, end_date, total_count, page_size=50000):
         """
         Stream the serialized data.
         """
-        total_rows = enrollments.shape[0]
-        for start_index in range(0, total_rows, chunk_size):
-            end_index = min(start_index + chunk_size, total_rows)
-            chunk = enrollments.iloc[start_index:end_index]
-            yield from chunk.to_dict(orient='records')
-
-
-class AdvanceAnalyticsEnrollmentStatsView(APIView):
-    """
-    API for getting the advance analytics enrollment chart stats.
-    """
-    authentication_classes = (JwtAuthentication,)
-    http_method_names = ['get']
+        offset = 0
+        while offset < total_count:
+            enrollments = FactEnrollmentAdminDashTable().get_all_enrollments(
+                enterprise_customer_uuid=enterprise_uuid,
+                start_date=start_date,
+                end_date=end_date,
+                limit=page_size,
+                offset=offset,
+            )
+            yield from enrollments
+            offset += page_size
 
     @permission_required('can_access_enterprise', fn=lambda request, enterprise_uuid: enterprise_uuid)
-    def get(self, request, enterprise_uuid):  # lint-amnesty, pylint: disable=inconsistent-return-statements
-        """Get enrollment chart stats"""
-        serializer = AdvanceAnalyticsEnrollmentStatsSerializer(data=request.GET)
-        serializer.is_valid(raise_exception=True)
-
-        cache_expiry = fetch_enrollments_cache_expiry_timestamp()
-        enrollments_df = fetch_and_cache_enrollments_data(enterprise_uuid, cache_expiry)
-
-        # get values from query params or use default
-        start_date = serializer.data.get('start_date', enrollments_df.enterprise_enrollment_date.min())
-        end_date = serializer.data.get('end_date', datetime.now())
-        granularity = serializer.data.get('granularity', Granularity.DAILY.value)
-        calculation = serializer.data.get('calculation', Calculation.TOTAL.value)
-        response_type = serializer.data.get('response_type', ResponseType.JSON.value)
-        chart_type = serializer.data.get('chart_type')
-
-        # TODO: Add validation that if response_type is CSV then chart_type must be provided
-
-        if response_type == ResponseType.JSON.value:
-            with timer('construct_enrollment_all_stats'):
-                data = {
-                    "enrollments_over_time": self.construct_enrollments_over_time(
-                        enrollments_df.copy(),
-                        start_date,
-                        end_date,
-                        granularity,
-                        calculation,
-                    ),
-                    "top_courses_by_enrollments": self.construct_top_courses_by_enrollments(
-                        enrollments_df.copy(),
-                        start_date,
-                        end_date,
-                    ),
-                    "top_subjects_by_enrollments": self.construct_top_subjects_by_enrollments(
-                        enrollments_df.copy(),
-                        start_date,
-                        end_date,
-                    ),
-                }
-            return Response(data)
-
-        if response_type == ResponseType.CSV.value:
-            if chart_type == EnrollmentChart.ENROLLMENTS_OVER_TIME.value:
-                with timer('construct_enrollments_over_time_csv'):
-                    return self.construct_enrollments_over_time_csv(
-                        enrollments_df.copy(),
-                        start_date,
-                        end_date,
-                        granularity,
-                        calculation,
-                    )
-            elif chart_type == EnrollmentChart.TOP_COURSES_BY_ENROLLMENTS.value:
-                with timer('construct_top_courses_by_enrollments_csv'):
-                    return self.construct_top_courses_by_enrollments_csv(
-                        enrollments_df.copy(),
-                        start_date,
-                        end_date,
-                    )
-            elif chart_type == EnrollmentChart.TOP_SUBJECTS_BY_ENROLLMENTS.value:
-                with timer('construct_top_subjects_by_enrollments_csv'):
-                    return self.construct_top_subjects_by_enrollments_csv(
-                        enrollments_df.copy(),
-                        start_date,
-                        end_date,
-                    )
-
-    def enrollments_over_time_common(self, enrollments_df, start_date, end_date, granularity, calculation):
-        """
-        Common method for constructing enrollments over time data.
-
-        Arguments:
-            enrollments_df {DataFrame} -- DataFrame of enrollments
-            start_date {datetime} -- Enrollment start date in the format 'YYYY-MM-DD'
-            end_date {datetime} -- Enrollment end date in the format 'YYYY-MM-DD'
-            granularity {str} -- Granularity of the data. One of Granularity choices
-            calculation {str} -- Calculation of the data. One of Calculation choices
-        """
-        # filter enrollments by date
-        enrollments = date_filter(start_date, end_date, enrollments_df, "enterprise_enrollment_date")
-
-        # aggregate enrollments by granularity
-        enrollments = granularity_aggregation(
-            level=granularity,
-            group=["enterprise_enrollment_date", "enroll_type"],
-            date="enterprise_enrollment_date",
-            data_frame=enrollments,
-        )
-
-        # aggregate enrollments by calculation
-        enrollments = calculation_aggregation(calc=calculation, data_frame=enrollments)
-
-        return enrollments
-
-    def construct_enrollments_over_time(self, enrollments_df, start_date, end_date, granularity, calculation):
-        """
-        Construct enrollments over time data.
-
-        Arguments:
-            enrollments_df {DataFrame} -- DataFrame of enrollments
-            start_date {datetime} -- Enrollment start date in the format 'YYYY-MM-DD'
-            end_date {datetime} -- Enrollment end date in the format 'YYYY-MM-DD'
-            granularity {str} -- Granularity of the data. One of Granularity choices
-            calculation {str} -- Calculation of the data. One of Calculation choices
-        """
-        enrollments = self.enrollments_over_time_common(enrollments_df, start_date, end_date, granularity, calculation)
-
-        # convert dataframe to a list of records
-        return enrollments.to_dict(orient='records')
-
-    def construct_enrollments_over_time_csv(self, enrollments_df, start_date, end_date, granularity, calculation):
-        """
-        Construct enrollments over time CSV.
-
-        Arguments:
-            enrollments_df {DataFrame} -- DataFrame of enrollments
-            start_date {datetime} -- Enrollment start date in the format 'YYYY-MM-DD'
-            end_date {datetime} -- Enrollment end date in the format 'YYYY-MM-DD'
-            granularity {str} -- Granularity of the data. One of Granularity choices
-            calculation {str} -- Calculation of the data. One of Calculation choices
+    @action(detail=False, methods=['get'], name='Charts Data', url_path='stats')
+    def stats(self, request, enterprise_uuid):
         """
-        enrollments = self.enrollments_over_time_common(enrollments_df, start_date, end_date, granularity, calculation)
+        Get data to populate enterprise enrollment charts.
 
-        enrollments = enrollments.pivot(
-            index="enterprise_enrollment_date", columns="enroll_type", values="count"
-        )
-
-        filename = f"Enrollment Timeseries, {start_date} - {end_date} ({granularity} {calculation}).csv"
-        return self.construct_csv_response(enrollments, filename)
-
-    def top_courses_by_enrollments_common(self, enrollments_df, start_date, end_date, group_by_columns, columns):
-        """
-        Common method for constructing top courses by enrollments data.
-
-        Arguments:
-            enrollments_df {DataFrame} -- DataFrame of enrollments
-            start_date {datetime} -- Enrollment start date in the format 'YYYY-MM-DD'
-            end_date {datetime} -- Enrollment end date in the format 'YYYY-MM-DD'
-            group_by_columns {list} -- List of columns to group by
-            columns {list} -- List of column for the final result
-        """
-        # filter enrollments by date
-        enrollments = date_filter(start_date, end_date, enrollments_df, "enterprise_enrollment_date")
-
-        courses = list(
-            enrollments.groupby(["course_key"]).size().sort_values(ascending=False)[:10].index
-        )
-
-        enrollments = (
-            enrollments[enrollments.course_key.isin(courses)]
-            .groupby(group_by_columns)
-            .size()
-            .reset_index()
-        )
-        enrollments.columns = columns
-
-        return enrollments
-
-    def construct_top_courses_by_enrollments(self, enrollments_df, start_date, end_date):
-        """
-        Construct top courses by enrollments data.
-
-        Arguments:
-            enrollments_df {DataFrame} -- DataFrame of enrollments
-            start_date {datetime} -- Enrollment start date in the format 'YYYY-MM-DD'
-            end_date {datetime} -- Enrollment end date in the format 'YYYY-MM-DD'
+        Here is the list of the charts and their corresponding data:
+        1. `enrollments_over_time`: This will show time series data of enrollments over time.
+        2. `top_courses_by_enrollments`: This will show the top courses by enrollments.
+        3. `top_subjects_by_enrollments`: This will show the top subjects by enrollments.
         """
-        group_by_columns = ["course_key", "enroll_type"]
-        columns = ["course_key", "enroll_type", "count"]
-        enrollments = self.top_courses_by_enrollments_common(
-            enrollments_df,
-            start_date,
-            end_date,
-            group_by_columns,
-            columns
-        )
-
-        # convert dataframe to a list of records
-        return enrollments.to_dict(orient='records')
-
-    def construct_top_courses_by_enrollments_csv(self, enrollments_df, start_date, end_date):
-        """
-        Construct top courses by enrollments CSV.
-
-        Arguments:
-            enrollments_df {DataFrame} -- DataFrame of enrollments
-            start_date {datetime} -- Enrollment start date in the format 'YYYY-MM-DD'
-            end_date {datetime} -- Enrollment end date in the format 'YYYY-MM-DD'
-        """
-        group_by_columns = ["course_key", "course_title", "enroll_type"]
-        columns = ["course_key", "course_title", "enroll_type", "count"]
-        enrollments = self.top_courses_by_enrollments_common(
-            enrollments_df,
-            start_date,
-            end_date,
-            group_by_columns,
-            columns
-        )
-
-        enrollments = enrollments.pivot(
-            index=["course_key", "course_title"], columns="enroll_type", values="count"
-        )
+        # Remove hyphens from the UUID
+        enterprise_uuid = enterprise_uuid.replace('-', '')
 
-        filename = f"Top 10 Courses, {start_date} - {end_date}.csv"
-        return self.construct_csv_response(enrollments, filename)
-
-    def top_subjects_by_enrollments_common(self, enrollments_df, start_date, end_date):
-        """
-        Common method for constructing top subjects by enrollments data.
-
-        Arguments:
-            enrollments_df {DataFrame} -- DataFrame of enrollments
-            start_date {datetime} -- Enrollment start date in the format 'YYYY-MM-DD'
-            end_date {datetime} -- Enrollment end date in the format 'YYYY-MM-DD'
-        """
-        # filter enrollments by date
-        enrollments = date_filter(start_date, end_date, enrollments_df, "enterprise_enrollment_date")
-
-        subjects = list(
-            enrollments.groupby(["course_subject"]).size().sort_values(ascending=False)[:10].index
-        )
+        serializer = AdvanceAnalyticsEnrollmentStatsSerializer(data=request.GET)
+        serializer.is_valid(raise_exception=True)
 
-        enrollments = (
-            enrollments[enrollments.course_subject.isin(subjects)]
-            .groupby(["course_subject", "enroll_type"])
-            .size()
-            .reset_index()
+        min_enrollment_date, _ = FactEnrollmentAdminDashTable().get_enrollment_date_range(
+            enterprise_uuid,
         )
-        enrollments.columns = ["course_subject", "enroll_type", "count"]
-
-        return enrollments
-
-    def construct_top_subjects_by_enrollments(self, enrollments_df, start_date, end_date):
-        """
-        Construct top subjects by enrollments data.
-
-        Arguments:
-            enrollments_df {DataFrame} -- DataFrame of enrollments
-            start_date {datetime} -- Enrollment start date in the format 'YYYY-MM-DD'
-            end_date {datetime} -- Enrollment end date in the format 'YYYY-MM-DD'
-        """
-        enrollments = self.top_subjects_by_enrollments_common(enrollments_df, start_date, end_date)
-        # convert dataframe to a list of records
-        return enrollments.to_dict(orient='records')
-
-    def construct_top_subjects_by_enrollments_csv(self, enrollments_df, start_date, end_date):
-        """
-        Construct top subjects by enrollments CSV.
-
-        Arguments:
-            enrollments_df {DataFrame} -- DataFrame of enrollments
-            start_date {datetime} -- Enrollment start date in the format 'YYYY-MM-DD'
-            end_date {datetime} -- Enrollment end date in the format 'YYYY-MM-DD'
-        """
-        enrollments = self.top_subjects_by_enrollments_common(enrollments_df, start_date, end_date)
-        enrollments = enrollments.pivot(index="course_subject", columns="enroll_type", values="count")
-
-        filename = f"Top 10 Subjects by Enrollment, {start_date} - {end_date}.csv"
-        return self.construct_csv_response(enrollments, filename)
-
-    def construct_csv_response(self, enrollments, filename):
-        """
-        Construct CSV response.
-
-        Arguments:
-            enrollments {DataFrame} -- DataFrame of enrollments
-            filename {str} -- Filename for the CSV
-        """
-        response = HttpResponse(content_type='text/csv')
-        response['Content-Disposition'] = f'attachment; filename="{filename}"'
-        response['Access-Control-Expose-Headers'] = 'Content-Disposition'
-        enrollments.to_csv(path_or_buf=response)
-
-        return response
+        # get values from query params or use default
+        start_date = serializer.data.get('start_date', min_enrollment_date)
+        end_date = serializer.data.get('end_date', datetime.now())
+        with timer('construct_enrollment_all_stats'):
+            data = {
+                'enrollments_over_time': FactEnrollmentAdminDashTable().get_enrolment_time_series_data(
+                    enterprise_uuid, start_date, end_date
+                ),
+                'top_courses_by_enrollments': FactEnrollmentAdminDashTable().get_top_courses_by_enrollments(
+                    enterprise_uuid, start_date, end_date,
+                ),
+                'top_subjects_by_enrollments': FactEnrollmentAdminDashTable().get_top_subjects_by_enrollments(
+                    enterprise_uuid, start_date, end_date,
+                ),
+            }
+        return Response(data)

enterprise_data/api/v1/views/base.py

@@ -1,9 +1,14 @@
 """
 Base views for enterprise data api v1.
 """
+import math
+
 from edx_rbac.mixins import PermissionRequiredMixin
 from edx_rest_framework_extensions.auth.jwt.authentication import JwtAuthentication
 from edx_rest_framework_extensions.paginators import DefaultPagination
+from rest_framework.exceptions import NotFound
+from rest_framework.response import Response
+from rest_framework.utils.urls import remove_query_param, replace_query_param
 
 from enterprise_data.constants import ANALYTICS_API_VERSION_1
 
@@ -24,3 +29,77 @@ class EnterpriseViewSetMixin(PermissionRequiredMixin):
         if 'no_page' in self.request.query_params:
             return None
         return super().paginate_queryset(queryset)
+
+
+class AnalyticsPaginationMixin:
+    """
+    Mixin that provides utility methods to allow pagination on views.
+    """
+    page_query_param = 'page'
+    page_size_query_param = 'page_size'
+
+    def get_next_link(self, request, page_number, page_count):
+        """
+        Get the link to the next page.
+
+        Arguments:
+            request (Request): The request object.
+            page_number (int): The current page number.
+            page_count (int): The total number of pages.
+
+        Returns:
+            str: The link to the next page.
+        """
+        if page_number >= page_count:
+            return None
+        return replace_query_param(
+            url=request.build_absolute_uri(),
+            key=self.page_query_param,
+            val=page_number + 1,
+        )
+
+    def get_previous_link(self, request, page_number):
+        """
+        Get the link to the previous page.
+
+        Arguments:
+            request (Request): The request object.
+            page_number (int): The current page number.
+
+        Returns:
+            str: The link to the previous page.
+        """
+        if page_number <= 1:
+            return None
+        url = request.build_absolute_uri()
+        next_page = page_number - 1
+        if next_page == 1:
+            return remove_query_param(url, self.page_query_param)
+        return replace_query_param(url, self.page_query_param, next_page)
+
+    def get_paginated_response(self, request, records, page, page_size, total_count):
+        """
+        Get pagination data.
+
+        Arguments:
+            request (Request): The request object.
+            records (list): The records to return.
+            page (int): The current page number.
+            page_size (int): The number of records per page.
+            total_count (int): The total number of records
+
+        Returns:
+            (Response): The pagination data.
+        """
+        page_count = math.ceil(total_count / page_size)
+        if page_count > 0 and (page <= 0 or page > page_count):
+            raise NotFound('Invalid page.')
+
+        return Response({
+            'next': self.get_next_link(request, page, page_count),
+            'previous': self.get_previous_link(request, page),
+            'count': total_count,
+            'num_pages': page_count,
+            'current_page': page,
+            'results': records,
+        })

enterprise_data/tests/admin_analytics/mock_analytics_data.py

@@ -384,18 +384,6 @@ def engagements_dataframe():
     return engagements
 
 
-def enrollments_csv_content():
-    """Return the CSV content of enrollments."""
-    return (
-        b'email,course_title,course_subject,enroll_type,enterprise_enrollment_date\r\n'
-        b'rebeccanelson@example.com,Re-engineered tangible approach,business-management,certificate,2021-07-04\r\n'
-        b'taylorjames@example.com,Re-engineered tangible approach,business-management,certificate,2021-07-03\r\n'
-        b'ssmith@example.com,Secured static capability,medicine,certificate,2021-05-11\r\n'
-        b'amber79@example.com,Streamlined zero-defect attitude,communication,certificate,2020-04-08\r\n'
-        b'kathleenmartin@example.com,Horizontal solution-oriented hub,social-sciences,certificate,2020-04-03\r\n'
-    )
-
-
 def leaderboard_csv_content():
     """Return the CSV content of leaderboard."""
     # return (

enterprise_data/tests/admin_analytics/test_analytics_enrollments.py

@@ -1,5 +1,4 @@
 """Unittests for analytics_enrollments.py"""
-
 from datetime import datetime
 
 import ddt
@@ -8,15 +7,10 @@ from rest_framework import status
 from rest_framework.reverse import reverse
 from rest_framework.test import APITransactionTestCase
 
-from enterprise_data.admin_analytics.constants import EnrollmentChart, ResponseType
+from enterprise_data.admin_analytics.constants import ResponseType
 from enterprise_data.api.v1.serializers import AdvanceAnalyticsEnrollmentStatsSerializer as EnrollmentStatsSerializer
 from enterprise_data.api.v1.serializers import AdvanceAnalyticsQueryParamSerializer
-from enterprise_data.tests.admin_analytics.mock_analytics_data import (
-    ENROLLMENT_STATS_CSVS,
-    ENROLLMENTS,
-    enrollments_csv_content,
-    enrollments_dataframe,
-)
+from enterprise_data.tests.admin_analytics.mock_analytics_data import ENROLLMENTS
 from enterprise_data.tests.mixins import JWTTestMixin
 from enterprise_data.tests.test_utils import UserFactory
 from enterprise_data_roles.constants import ENTERPRISE_DATA_ADMIN_ROLE
@@ -59,8 +53,8 @@ class TestIndividualEnrollmentsAPI(JWTTestMixin, APITransactionTestCase):
         )
 
         fetch_max_enrollment_datetime_patcher = patch(
-            'enterprise_data.api.v1.views.analytics_enrollments.fetch_enrollments_cache_expiry_timestamp',
-            return_value=datetime.now()
+            'enterprise_data.api.v1.views.analytics_enrollments.FactEnrollmentAdminDashTable.get_enrollment_date_range',
+            return_value=(datetime.now(), datetime.now())
         )
 
         fetch_max_enrollment_datetime_patcher.start()
@@ -69,11 +63,11 @@ class TestIndividualEnrollmentsAPI(JWTTestMixin, APITransactionTestCase):
     def verify_enrollment_data(self, results, results_count):
         """Verify the received enrollment data."""
         attrs = [
-            "email",
-            "course_title",
-            "course_subject",
-            "enroll_type",
-            "enterprise_enrollment_date",
+            'email',
+            'course_title',
+            'course_subject',
+            'enroll_type',
+            'enterprise_enrollment_date',
         ]
 
         assert len(results) == results_count
@@ -89,16 +83,16 @@ class TestIndividualEnrollmentsAPI(JWTTestMixin, APITransactionTestCase):
         expected_data = sorted(filtered_data, key=lambda x: x["email"])
         assert received_data == expected_data
 
-    @patch(
-        "enterprise_data.api.v1.views.analytics_enrollments.fetch_and_cache_enrollments_data"
-    )
-    def test_get(self, mock_fetch_and_cache_enrollments_data):
+    @patch('enterprise_data.api.v1.views.analytics_enrollments.FactEnrollmentAdminDashTable.get_enrollment_count')
+    @patch('enterprise_data.api.v1.views.analytics_enrollments.FactEnrollmentAdminDashTable.get_all_enrollments')
+    def test_get(self, mock_get_all_enrollments, mock_get_enrollment_count):
         """
         Test the GET method for the AdvanceAnalyticsIndividualEnrollmentsView works.
         """
-        mock_fetch_and_cache_enrollments_data.return_value = enrollments_dataframe()
+        mock_get_all_enrollments.return_value = ENROLLMENTS
+        mock_get_enrollment_count.return_value = len(ENROLLMENTS)
 
-        response = self.client.get(self.url, {"page_size": 2})
+        response = self.client.get(self.url + '?page_size=2')
         assert response.status_code == status.HTTP_200_OK
         assert response["Content-Type"] == "application/json"
         data = response.json()
@@ -107,9 +101,8 @@ class TestIndividualEnrollmentsAPI(JWTTestMixin, APITransactionTestCase):
         assert data["current_page"] == 1
         assert data["num_pages"] == 3
         assert data["count"] == 5
-        self.verify_enrollment_data(data["results"], 2)
 
-        response = self.client.get(self.url, {"page_size": 2, "page": 2})
+        response = self.client.get(self.url + '?page_size=2&page=2')
         assert response.status_code == status.HTTP_200_OK
         assert response["Content-Type"] == "application/json"
         data = response.json()
@@ -118,9 +111,8 @@ class TestIndividualEnrollmentsAPI(JWTTestMixin, APITransactionTestCase):
         assert data["current_page"] == 2
         assert data["num_pages"] == 3
         assert data["count"] == 5
-        self.verify_enrollment_data(data["results"], 2)
 
-        response = self.client.get(self.url, {"page_size": 2, "page": 3})
+        response = self.client.get(self.url + '?page_size=2&page=3')
         assert response.status_code == status.HTTP_200_OK
         assert response["Content-Type"] == "application/json"
         data = response.json()
@@ -129,9 +121,8 @@ class TestIndividualEnrollmentsAPI(JWTTestMixin, APITransactionTestCase):
         assert data["current_page"] == 3
         assert data["num_pages"] == 3
         assert data["count"] == 5
-        self.verify_enrollment_data(data["results"], 1)
 
-        response = self.client.get(self.url, {"page_size": 5})
+        response = self.client.get(self.url + '?page_size=5')
         assert response.status_code == status.HTTP_200_OK
         assert response["Content-Type"] == "application/json"
         data = response.json()
@@ -140,16 +131,15 @@ class TestIndividualEnrollmentsAPI(JWTTestMixin, APITransactionTestCase):
         assert data["current_page"] == 1
         assert data["num_pages"] == 1
         assert data["count"] == 5
-        self.verify_enrollment_data(data["results"], 5)
 
-    @patch(
-        "enterprise_data.api.v1.views.analytics_enrollments.fetch_and_cache_enrollments_data"
-    )
-    def test_get_csv(self, mock_fetch_and_cache_enrollments_data):
+    @patch('enterprise_data.api.v1.views.analytics_enrollments.FactEnrollmentAdminDashTable.get_enrollment_count')
+    @patch('enterprise_data.api.v1.views.analytics_enrollments.FactEnrollmentAdminDashTable.get_all_enrollments')
+    def test_get_csv(self, mock_get_all_enrollments, mock_get_enrollment_count):
         """
         Test the GET method for the AdvanceAnalyticsIndividualEnrollmentsView return correct CSV data.
         """
-        mock_fetch_and_cache_enrollments_data.return_value = enrollments_dataframe()
+        mock_get_all_enrollments.return_value = ENROLLMENTS
+        mock_get_enrollment_count.return_value = len(ENROLLMENTS)
         response = self.client.get(self.url, {"response_type": ResponseType.CSV.value})
         assert response.status_code == status.HTTP_200_OK
 
@@ -157,8 +147,33 @@ class TestIndividualEnrollmentsAPI(JWTTestMixin, APITransactionTestCase):
         assert response["Content-Type"] == "text/csv"
 
         # verify the response content
-        content = b"".join(response.streaming_content)
-        assert content == enrollments_csv_content()
+        content = b"".join(response.streaming_content).decode().splitlines()
+        assert len(content) == 6
+
+        # Verify CSV header.
+        assert 'email,course_title,course_subject,enroll_type,enterprise_enrollment_date' == content[0]
+
+        # verify the content
+        assert (
+            'rebeccanelson@example.com,Re-engineered tangible approach,business-management,certificate,2021-07-04'
+            in content
+        )
+        assert (
+            'taylorjames@example.com,Re-engineered tangible approach,business-management,certificate,2021-07-03'
+            in content
+        )
+        assert (
+            'ssmith@example.com,Secured static capability,medicine,certificate,2021-05-11'
+            in content
+        )
+        assert (
+            'amber79@example.com,Streamlined zero-defect attitude,communication,certificate,2020-04-08'
+            in content
+        )
+        assert (
+            'kathleenmartin@example.com,Horizontal solution-oriented hub,social-sciences,certificate,2020-04-03'
+            in content
+        )
 
     @ddt.data(
         {
@@ -232,8 +247,8 @@ class TestEnrollmentStatsAPI(JWTTestMixin, APITransactionTestCase):
         )
 
         fetch_max_enrollment_datetime_patcher = patch(
-            'enterprise_data.api.v1.views.analytics_enrollments.fetch_enrollments_cache_expiry_timestamp',
-            return_value=datetime.now()
+            'enterprise_data.api.v1.views.analytics_enrollments.FactEnrollmentAdminDashTable.get_enrollment_date_range',
+            return_value=(datetime.now(), datetime.now())
         )
 
         fetch_max_enrollment_datetime_patcher.start()
@@ -261,93 +276,35 @@ class TestEnrollmentStatsAPI(JWTTestMixin, APITransactionTestCase):
         assert received_data == expected_data
 
     @patch(
-        "enterprise_data.api.v1.views.analytics_enrollments.fetch_and_cache_enrollments_data"
+        'enterprise_data.api.v1.views.analytics_enrollments.FactEnrollmentAdminDashTable.'
+        'get_top_subjects_by_enrollments'
+    )
+    @patch(
+        'enterprise_data.api.v1.views.analytics_enrollments.FactEnrollmentAdminDashTable.get_top_courses_by_enrollments'
+    )
+    @patch(
+        'enterprise_data.api.v1.views.analytics_enrollments.FactEnrollmentAdminDashTable.get_enrolment_time_series_data'
     )
-    def test_get(self, mock_fetch_and_cache_enrollments_data):
+    def test_get(
+            self,
+            mock_get_enrolment_time_series_data,
+            mock_get_top_courses_by_enrollments,
+            mock_get_top_subjects_by_enrollments,
+    ):
         """
         Test the GET method for the AdvanceAnalyticsEnrollmentStatsView works.
         """
-        mock_fetch_and_cache_enrollments_data.return_value = enrollments_dataframe()
+        mock_get_enrolment_time_series_data.return_value = []
+        mock_get_top_courses_by_enrollments.return_value = []
+        mock_get_top_subjects_by_enrollments.return_value = []
 
         response = self.client.get(self.url)
         assert response.status_code == status.HTTP_200_OK
         assert response["Content-Type"] == "application/json"
         data = response.json()
-        assert data == {
-            "enrollments_over_time": [
-                {
-                    "enterprise_enrollment_date": "2020-04-03T00:00:00",
-                    "enroll_type": "certificate",
-                    "count": 1,
-                },
-                {
-                    "enterprise_enrollment_date": "2020-04-08T00:00:00",
-                    "enroll_type": "certificate",
-                    "count": 1,
-                },
-                {
-                    "enterprise_enrollment_date": "2021-05-11T00:00:00",
-                    "enroll_type": "certificate",
-                    "count": 1,
-                },
-                {
-                    "enterprise_enrollment_date": "2021-07-03T00:00:00",
-                    "enroll_type": "certificate",
-                    "count": 1,
-                },
-                {
-                    "enterprise_enrollment_date": "2021-07-04T00:00:00",
-                    "enroll_type": "certificate",
-                    "count": 1,
-                },
-            ],
-            "top_courses_by_enrollments": [
-                {"course_key": "NOGk+UVD31", "enroll_type": "certificate", "count": 1},
-                {"course_key": "QWXx+Jqz64", "enroll_type": "certificate", "count": 1},
-                {"course_key": "hEmW+tvk03", "enroll_type": "certificate", "count": 2},
-                {"course_key": "qZJC+KFX86", "enroll_type": "certificate", "count": 1},
-            ],
-            "top_subjects_by_enrollments": [
-                {
-                    "course_subject": "business-management",
-                    "enroll_type": "certificate",
-                    "count": 2,
-                },
-                {
-                    "course_subject": "communication",
-                    "enroll_type": "certificate",
-                    "count": 1,
-                },
-                {
-                    "course_subject": "medicine",
-                    "enroll_type": "certificate",
-                    "count": 1,
-                },
-                {
-                    "course_subject": "social-sciences",
-                    "enroll_type": "certificate",
-                    "count": 1,
-                },
-            ],
-        }
-
-    @patch("enterprise_data.api.v1.views.analytics_enrollments.fetch_and_cache_enrollments_data")
-    @ddt.data(
-        EnrollmentChart.ENROLLMENTS_OVER_TIME.value,
-        EnrollmentChart.TOP_COURSES_BY_ENROLLMENTS.value,
-        EnrollmentChart.TOP_SUBJECTS_BY_ENROLLMENTS.value,
-    )
-    def test_get_csv(self, chart_type, mock_fetch_and_cache_enrollments_data):
-        """
-        Test that AdvanceAnalyticsEnrollmentStatsView return correct CSV data.
-        """
-        mock_fetch_and_cache_enrollments_data.return_value = enrollments_dataframe()
-
-        response = self.client.get(self.url, {"response_type": ResponseType.CSV.value, "chart_type": chart_type})
-        assert response.status_code == status.HTTP_200_OK
-        assert response["Content-Type"] == "text/csv"
-        # verify the response content
-        assert response.content == ENROLLMENT_STATS_CSVS[chart_type]
+        assert 'enrollments_over_time' in data
+        assert 'top_courses_by_enrollments' in data
+        assert 'top_subjects_by_enrollments' in data
 
     @ddt.data(
         {