Integrate pagination for personal data API

Signed-off-by: George J Padayatti <[email protected]>

Author: georgepadayatti

mydata_did/v1_0/manager.py

@@ -4345,7 +4345,7 @@ async def query_data_agreement_version_history(self, data_agreement_id: str) ->
                 f"Failed to fetch all data agreements from wallet; Reason: {e.roll_up}"
             )
 
-    def serialize_personal_data_record(self, *, personal_data_records: typing.List[DataAgreementPersonalDataRecord], is_list: bool = True) -> typing.List[dict]:
+    def serialize_personal_data_record(self, *, personal_data_records: typing.List[dict], is_list: bool = True) -> typing.List[dict]:
         """
         Serialize personal data records.
 
@@ -4357,26 +4357,11 @@ def serialize_personal_data_record(self, *, personal_data_records: typing.List[D
             Serialized personal data records.
         """
 
-        personal_data_records_list: typing.List[dict] = []
-
-        for personal_data_record in personal_data_records:
-            temp_personal_data_record = {
-                "attribute_id": personal_data_record.personal_data_id,
-                "attribute_name": personal_data_record.attribute_name,
-                "attribute_description": personal_data_record.attribute_description,
-                "data_agreement_template_id": personal_data_record.da_template_id,
-                "data_agreement_template_version": personal_data_record.da_template_version,
-                "created_at": str_to_epoch(personal_data_record.created_at),
-                "updated_at": str_to_epoch(personal_data_record.updated_at),
-            }
-
-            personal_data_records_list.append(temp_personal_data_record)
-
         # Sort personal data list by created_at in descending order
-        personal_data_records_list = sorted(
-            personal_data_records_list, key=lambda k: k['created_at'], reverse=True)
+        personal_data_records = sorted(
+            personal_data_records, key=lambda k: k['created_at'], reverse=True)
 
-        return personal_data_records_list if is_list else personal_data_records_list[0]
+        return personal_data_records if is_list else personal_data_records[0]
 
     async def update_personal_data_description(self, personal_data_id: str, updated_description: str) -> typing.Tuple[DataAgreementPersonalDataRecord, dict]:
 
@@ -4439,7 +4424,7 @@ async def update_personal_data_description(self, personal_data_id: str, updated_
         except (StorageError, ValidationError) as err:
             raise ADAManagerError(err_string.format(err=err)) from err
 
-    async def query_da_personal_data_in_wallet(self, personal_data_id: str = None) -> typing.Tuple[typing.List[DataAgreementPersonalDataRecord], dict]:
+    async def query_da_personal_data_in_wallet(self, personal_data_id: str = None, method_of_use: str = None) -> typing.List[dict]:
         """
         Query personal data in the wallet.
         """
@@ -4460,8 +4445,41 @@ async def query_da_personal_data_in_wallet(self, personal_data_id: str = None) -
             else:
                 matched_personal_data_records = personal_data_records
 
-            return matched_personal_data_records, self.serialize_personal_data_record(personal_data_records=matched_personal_data_records, is_list=True)
-        except StorageSearchError as e:
+            serialised_personal_data_records = []
+
+            # Iterate through personal data
+            for pd in matched_personal_data_records:
+
+                # Fetch data agreement template.
+                data_agreement_record: DataAgreementV1Record = await DataAgreementV1Record.retrieve_non_deleted_data_agreement_by_id(
+                    self.context,
+                    pd.da_template_id
+                )
+
+                temp_pd = {
+                    "attribute_id": pd.personal_data_id,
+                    "attribute_name": pd.attribute_name,
+                    "attribute_description": pd.attribute_description,
+                    "data_agreement": {
+                        "data_agreement_id": data_agreement_record.data_agreement_record_id,
+                        "method_of_use": data_agreement_record.method_of_use,
+                    },
+                    "created_at": str_to_epoch(pd.created_at),
+                    "updated_at": str_to_epoch(pd.updated_at),
+                }
+
+                if method_of_use:
+                    if data_agreement_record.method_of_use == method_of_use:
+                        serialised_personal_data_records.append(temp_pd)
+                else:
+                    serialised_personal_data_records.append(temp_pd)
+
+            return self.serialize_personal_data_record(
+                personal_data_records=serialised_personal_data_records,
+                is_list=True
+            )
+
+        except (StorageSearchError) as e:
             # Raise an error
             raise ADAManagerError(
                 f"Failed to fetch all data agreements from wallet: {e}"

mydata_did/v1_0/routes.py

@@ -1863,6 +1863,24 @@ class QueryDaPersonalDataInWalletQueryStringSchema(OpenAPISchema):
         example=UUIDFour.EXAMPLE
     )
 
+    page = fields.Int(
+        required=False,
+        description="Page number",
+        example=1,
+    )
+
+    page_size = fields.Int(
+        required=False,
+        description="Page size",
+        example=10,
+    )
+
+    method_of_use = fields.Str(
+        required=False,
+        description="Method of use",
+        example="data-using-service",
+    )
+
 
 @docs(
     tags=["Data Agreement - Core Functions"],
@@ -1886,15 +1904,55 @@ async def query_da_personal_data_in_wallet(request: web.BaseRequest):
     if "attribute_id" in request.query and request.query["attribute_id"] != "":
         personal_data_id = request.query["attribute_id"]
 
+    method_of_use = None
+    if "method_of_use" in request.query and request.query["method_of_use"] != "":
+        method_of_use = request.query["method_of_use"]
+
+    # Pagination parameters
+    pagination = {
+        "totalCount": 0,
+        "page": 0,
+        "pageSize": PAGINATION_PAGE_SIZE,
+        "totalPages": 0,
+    }
+
     try:
+
         # Query data agreement personal data in wallet
-        (data_agreement_personal_data_records, data_agreement_personal_data_dict_list) = await mydata_did_manager.query_da_personal_data_in_wallet(
-            personal_data_id=personal_data_id
+        results = await mydata_did_manager.query_da_personal_data_in_wallet(
+            personal_data_id=personal_data_id,
+            method_of_use=method_of_use
         )
+
+        # Page size from request.
+        page_size = int(request.query.get("page_size", PAGINATION_PAGE_SIZE))
+        pagination["pageSize"] = page_size
+
+        # Total number of records
+        pagination["totalCount"] = len(results)
+
+        # Total number of pages.
+        pagination["totalPages"] = math.ceil(
+            pagination["totalCount"] / pagination["pageSize"])
+
+        # Pagination parameters
+        page = request.query.get("page")
+
+        if page:
+            page = int(page)
+            pagination["page"] = page
+
+            lower, upper = get_slices(page, pagination["pageSize"])
+
+            results = results[lower:upper]
+
     except ADAManagerError as err:
         raise web.HTTPBadRequest(reason=err.roll_up) from err
 
-    return web.json_response(data_agreement_personal_data_dict_list)
+    return web.json_response({
+        "results": results,
+        "pagination": pagination if page else {}
+    })
 
 
 class UpdateDaPersonalDataInWalletMatchInfoSchema(OpenAPISchema):