Project history : Add functionnalities for the version viewerin the QGIS plugin

mergin/client.py

@@ -372,6 +372,24 @@ def workspace_service(self, workspace_id):
 
         return response
 
+    def workspace_usage(self, workspace_id):
+        """
+        This Requests information about a workspace usage from /workspace/{id}/usage endpoint,
+        if such exists in self.url server.
+
+        Returns response from server as JSON dict or None if endpoint is not found
+        """
+
+        try:
+            response = self.get(f"/v1/workspace/{workspace_id}/usage")
+        except ClientError as e:
+            self.log.debug(f"Unable to query for /workspace/{workspace_id}/usage endpoint")
+            return
+
+        response = json.loads(response.read())
+
+        return response
+
     def server_type(self):
         """
         Returns the deployment type of the server
@@ -700,41 +718,67 @@ def project_info(self, project_path_or_id, since=None, version=None):
             resp = self.get("/v1/project/{}".format(project_path_or_id), params)
         return json.load(resp)
 
-    def project_versions(self, project_path, since=None, to=None):
+    def project_versions_page(self, project_path, page, per_page=100, descending=False):
+        params = {"page": page, "per_page": per_page, "descending": descending}
+        resp = self.get("/v1/project/versions/paginated/{}".format(project_path), params)
+        resp_json = json.load(resp)
+        return resp_json["versions"]
+
+    def project_versions_count(self, project_path):
+        """
+        return the total count of versions
+
+        To note the requested informations are kept to the minimal
+        """
+        params = {"page": 1, "per_page": 1, "descending": False}
+        resp = self.get("/v1/project/versions/paginated/{}".format(project_path), params)
+        resp_json = json.load(resp)
+        return resp_json["count"]
+
+    def project_versions_in_range(self, project_path, since=None, to=None):
         """
         Get records of project's versions (history) in ascending order.
         If neither 'since' nor 'to' is specified it will return all versions.
 
         :param project_path: Project's full name (<namespace>/<name>)
-        :type project_path: String
+        :type project_path: String | Int
         :param since: Version to track project history from
-        :type since: String
+        :type since: String | Int
         :param to: Version to track project history to
         :type to: String
 
         :rtype: List[Dict]
         """
         versions = []
         per_page = 100  # server limit
-        num_since = int_version(since) if since else 1
-        num_to = int_version(to) if to else None  # we may not know yet
+
+        if type(since) == str:
+            num_since = int_version(since)
+        elif since == None:
+            num_since = 1
+        else:
+            # keep the since parameter as is
+            num_since = since
+
+        if type(to) == str:
+            num_to = int_version(to)
+        else:
+            # keep the to parameter as is
+            num_to = to
+
         start_page = math.ceil(num_since / per_page)
         if not num_to:
             # let's get first page and count
-            params = {"page": start_page, "per_page": per_page, "descending": False}
-            resp = self.get("/v1/project/versions/paginated/{}".format(project_path), params)
-            resp_json = json.load(resp)
-            versions = resp_json["versions"]
-            num_to = resp_json["count"]
+            versions = self.project_versions_page(project_path, start_page, per_page)
+            num_to = self.project_versions_count(project_path)
             latest_version = int_version(versions[-1]["name"])
             if latest_version < num_to:
-                versions += self.project_versions(project_path, f"v{latest_version+1}", f"v{num_to}")
+                # add yield here
+                versions += self.project_versions_in_range(project_path, f"v{latest_version+1}", f"v{num_to}")
         else:
             end_page = math.ceil(num_to / per_page)
             for page in range(start_page, end_page + 1):
-                params = {"page": page, "per_page": per_page, "descending": False}
-                resp = self.get("/v1/project/versions/paginated/{}".format(project_path), params)
-                versions += json.load(resp)["versions"]
+                versions += self.project_versions_page(project_path, page, per_page)
 
         # filter out versions not within range
         filtered_versions = list(filter(lambda v: (num_since <= int_version(v["name"]) <= num_to), versions))

mergin/client_pull.py

@@ -687,6 +687,8 @@ def download_diffs_async(mc, project_directory, file_path, versions):
     fetch_files = []
 
     for version in versions:
+        if version not in file_history["history"]:
+            continue  # skip if this file was not modified at this version
         version_data = file_history["history"][version]
         if "diff" not in version_data:
             continue  # skip if there is no diff in history

mergin/report.py

@@ -216,7 +216,7 @@ def create_report(mc, directory, since, to, out_file):
     mp = MerginProject(directory)
     project = mp.project_full_name()
     mp.log.info(f"--- Creating changesets report for {project} from {since} to {to if to else 'latest'} versions ----")
-    versions = mc.project_versions(project, since, to if to else None)
+    versions = mc.project_versions_in_range(project, since, to if to else None)
     versions_map = {v["name"]: v for v in versions}
     headers = ["file", "table", "author", "date", "time", "version", "operation", "length", "area", "count"]
     records = []

mergin/test/test_client.py

@@ -1989,23 +1989,23 @@ def test_project_versions_list(mc):
     assert project_info["version"] == "v5"
 
     # get all versions
-    versions = mc.project_versions(project)
+    versions = mc.project_versions_in_range(project)
     assert len(versions) == 5
     assert versions[0]["name"] == "v1"
     assert versions[-1]["name"] == "v5"
 
     # get first 3 versions
-    versions = mc.project_versions(project, to="v3")
+    versions = mc.project_versions_in_range(project, to="v3")
     assert len(versions) == 3
     assert versions[-1]["name"] == "v3"
 
     # get last 2 versions
-    versions = mc.project_versions(project, since="v4")
+    versions = mc.project_versions_in_range(project, since="v4")
     assert len(versions) == 2
     assert versions[0]["name"] == "v4"
 
     # get range v2-v4
-    versions = mc.project_versions(project, since="v2", to="v4")
+    versions = mc.project_versions_in_range(project, since="v2", to="v4")
     assert len(versions) == 3
     assert versions[0]["name"] == "v2"
     assert versions[-1]["name"] == "v4"