Project history : Add a version viewer windows in the plugin

Mergin/diff.py

@@ -3,12 +3,14 @@
 import base64
 import sqlite3
 import tempfile
+import glob
 
 from qgis.PyQt.QtCore import QVariant
 
 from qgis.PyQt.QtGui import QColor
 
 from qgis.core import (
+    QgsApplication,
     QgsVectorLayer,
     QgsFeature,
     QgsGeometry,
@@ -107,6 +109,18 @@ def parse_db_schema(db_file):
     return tables
 
 
+def db_schema_from_json(schema_json):
+    """Create map of tables from the schema JSON file"""
+    tables = {}  # key: name, value: TableSchema
+    for tbl in schema_json:
+        columns = []
+        for col in tbl["columns"]:
+            columns.append(ColumnSchema(col["name"], col["type"], "primary_key" in col and col["primary_key"]))
+
+        tables[tbl["table"]] = TableSchema(tbl["table"], columns)
+    return tables
+
+
 def parse_diff(geodiff, diff_file):
     """
     Parse binary GeoDiff changeset and return map of changes per table
@@ -206,6 +220,8 @@ def diff_table_to_features(diff_table, schema_table, fields, cols_to_flds, db_co
 
             for i in range(len(db_row)):
                 if i == geom_col_index:
+                    if db_row[i] == None:
+                        continue
                     wkb = parse_gpkg_geom_encoding(db_row[i])
                     g = QgsGeometry()
                     g.fromWkb(wkb)
@@ -228,6 +244,9 @@ def diff_table_to_features(diff_table, schema_table, fields, cols_to_flds, db_co
                 value = "?"
 
             if i == geom_col_index:
+                if value == None:
+                    # Empty geometry
+                    continue
                 wkb_with_gpkg_hdr = base64.decodebytes(value.encode("ascii"))
                 wkb = parse_gpkg_geom_encoding(wkb_with_gpkg_hdr)
                 g = QgsGeometry()
@@ -311,6 +330,80 @@ def make_local_changes_layer(mp, layer):
     return vl, ""
 
 
+def make_version_changes_layers(project_path, version):
+    geodiff = pygeodiff.GeoDiff()
+
+    layers = []
+    version_dir = os.path.join(project_path, ".mergin", ".cache", f"v{version}")
+    for f in glob.iglob(f"{version_dir}/*.gpkg"):
+        gpkg_file = os.path.join(version_dir, f)
+        schema_file = gpkg_file + "-schema.json"
+        if not os.path.exists(schema_file):
+            geodiff.schema("sqlite", "", gpkg_file, schema_file)
+
+        changeset_file = find_changeset_file(f, version_dir)
+        if changeset_file is None:
+            continue
+
+        with open(schema_file, encoding="utf-8") as fl:
+            data = fl.read()
+            schema_json = json.loads(data.replace("\n", "")).get("geodiff_schema")
+
+        db_schema = db_schema_from_json(schema_json)
+        diff = parse_diff(geodiff, changeset_file)
+
+        for table_name in diff.keys():
+            if table_name.startswith("gpkg_"):
+                # db schema reported by geodiff exclude layer named "gpkg_*"
+                # We skip it in the layer displayed to the user
+                continue
+            fields, cols_to_fields = create_field_list(db_schema[table_name])
+            geom_type, geom_crs = get_layer_geometry_info(schema_json, table_name)
+
+            db_conn = None  # no ref. db
+            db_conn = sqlite3.connect(gpkg_file)
+
+            features = diff_table_to_features(diff[table_name], db_schema[table_name], fields, cols_to_fields, db_conn)
+
+            # create diff layer
+            if geom_type is None:
+                continue
+
+            uri = f"{geom_type}?crs=epsg:{geom_crs}" if geom_crs else geom_type
+            vl = QgsVectorLayer(uri, table_name, "memory")
+            if not vl.isValid():
+                continue
+
+            vl.dataProvider().addAttributes(fields)
+            vl.updateFields()
+            vl.dataProvider().addFeatures(features)
+
+            style_diff_layer(vl, db_schema[table_name])
+            layers.append(vl)
+
+    return layers
+
+
+def find_changeset_file(file_name, version_dir):
+    """Returns path to the diff file for the given version file"""
+    for f in glob.iglob(f"{version_dir}/*.gpkg-diff*"):
+        if f.startswith(file_name):
+            return os.path.join(version_dir, f)
+    return None
+
+
+def get_layer_geometry_info(schema_json, table_name):
+    """Returns geometry type and CRS for a given table"""
+    for tbl in schema_json:
+        if tbl["table"] == table_name:
+            for col in tbl["columns"]:
+                if col["type"] == "geometry":
+                    return col["geometry"]["type"], col["geometry"]["srs_id"]
+            return "NoGeometry", ""
+
+    return None, None
+
+
 def style_diff_layer(layer, schema_table):
     """Apply conditional styling and symbology to diff layer"""
     ### setup conditional styles!

Mergin/diff_dialog.py

@@ -18,14 +18,14 @@
 from qgis.utils import iface, OverrideCursor
 
 from .mergin.merginproject import MerginProject
-from .diff import make_local_changes_layer
-from .utils import icon_path
+from .diff import make_local_changes_layer, make_version_changes_layers
+from .utils import icon_path, icon_for_layer
 
 ui_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), "ui", "ui_diff_viewer_dialog.ui")
 
 
 class DiffViewerDialog(QDialog):
-    def __init__(self, parent=None):
+    def __init__(self, version=None, parent=None):
         QDialog.__init__(self, parent)
         self.ui = uic.loadUi(ui_file, self)
 
@@ -46,7 +46,7 @@ def __init__(self, parent=None):
             )
             self.toggle_layers_action.setCheckable(True)
             self.toggle_layers_action.setChecked(True)
-            self.toggle_layers_action.toggled.connect(self.toggle_project_layers)
+            self.toggle_layers_action.toggled.connect(self.toggle_background_layers)
             self.toolbar.addAction(self.toggle_layers_action)
 
             self.toolbar.addSeparator()
@@ -91,6 +91,8 @@ def __init__(self, parent=None):
             self.diff_layers = []
             self.filter_model = None
 
+            self.version = version
+
             self.create_tabs()
 
     def reject(self):
@@ -106,6 +108,12 @@ def save_splitter_state(self):
         settings.setValue("Mergin/changesViewerSplitterSize", self.splitter.saveState())
 
     def create_tabs(self):
+        if self.version is None:
+            self.show_local_changes()
+        else:
+            self.show_version_changes()
+
+    def show_local_changes(self):
         mp = MerginProject(QgsProject.instance().homePath())
         project_layers = QgsProject.instance().mapLayers()
         for layer in project_layers.values():
@@ -122,10 +130,17 @@ def create_tabs(self):
                 continue
 
             self.diff_layers.append(vl)
-            self.tab_bar.addTab(self.icon_for_layer(vl), f"{layer.name()} ({vl.featureCount()})")
+            self.tab_bar.addTab(icon_for_layer(vl), f"{layer.name()} ({vl.featureCount()})")
+        self.tab_bar.setCurrentIndex(0)
+
+    def show_version_changes(self):
+        layers = make_version_changes_layers(QgsProject.instance().homePath(), self.version)
+        for vl in layers:
+            self.diff_layers.append(vl)
+            self.tab_bar.addTab(icon_for_layer(vl), f"{vl.name()} ({vl.featureCount()})")
         self.tab_bar.setCurrentIndex(0)
 
-    def toggle_project_layers(self, checked):
+    def toggle_background_layers(self, checked):
         layers = self.collect_layers(checked)
         self.update_canvas(layers)
 
@@ -141,8 +156,8 @@ def update_canvas(self, layers):
             self.map_canvas.setExtent(extent)
         self.map_canvas.refresh()
 
-    def collect_layers(self, checked):
-        if checked:
+    def collect_layers(self, include_background_layers: bool):
+        if include_background_layers:
             layers = iface.mapCanvas().layers()
         else:
             layers = []
@@ -199,19 +214,6 @@ def zoom_selected(self):
             self.map_canvas.zoomToSelected([self.current_diff])
             self.map_canvas.refresh()
 
-    def icon_for_layer(self, layer):
-        geom_type = layer.geometryType()
-        if geom_type == QgsWkbTypes.PointGeometry:
-            return QgsApplication.getThemeIcon("/mIconPointLayer.svg")
-        elif geom_type == QgsWkbTypes.LineGeometry:
-            return QgsApplication.getThemeIcon("/mIconLineLayer.svg")
-        elif geom_type == QgsWkbTypes.PolygonGeometry:
-            return QgsApplication.getThemeIcon("/mIconPolygonLayer.svg")
-        elif geom_type == QgsWkbTypes.UnknownGeometry:
-            return QgsApplication.getThemeIcon("/mIconGeometryCollectionLayer.svg")
-        else:
-            return QgsApplication.getThemeIcon("/mIconTableLayer.svg")
-
     def show_unsaved_changes_warning(self):
         self.ui.messageBar.pushMessage(
             "Mergin",