def addWFS(self):
if self.wfs == None: return
try:
lyrs = getWFSLayerNames(self.wfs, self.proxy)
except:
self.bar.pushMessage("Error", str(sys.exc_info()[1]), level=Qgis.Critical, duration=10)
return
if len(lyrs) == 0:
self.bar.pushMessage("WFS",
QCoreApplication.translate("geopunt4QgisDataCatalog",
"Kan geen lagen vinden in: %s" % self.wfs), level=Qgis.Warning, duration=10)
return
elif len(lyrs) == 1:
layerTitle = lyrs[0][1]
else:
layerTitle, accept = QInputDialog.getItem(self, "WFS toevoegen",
"Kies een laag om toe te voegen", [n[1] for n in lyrs],
editable=0)
if not accept: return
layerName = [n[0] for n in lyrs if n[1] == layerTitle][0]
crs = [n[2] for n in lyrs if n[1] == layerTitle][0]
url = self.wfs.split('?')[0]
wfsUri = makeWFSuri(url, layerName, crs )
try:
vlayer = QgsVectorLayer(wfsUri, layerTitle, "WFS")
QgsProject.instance().addMapLayer(vlayer)
except:
self.bar.pushMessage("Error", str(sys.exc_info()[1]), level=Qgis.Critical, duration=10)
return
def useLayerExtent(self):
CANVAS_KEY = "Use canvas extent"
extentsDict = {}
extentsDict[CANVAS_KEY] = {
"extent": iface.mapCanvas().extent(),
"authid": iface.mapCanvas().mapSettings().destinationCrs().authid(),
}
extents = [CANVAS_KEY]
layers = dataobjects.getAllLayers()
for layer in layers:
authid = layer.crs().authid()
if ProcessingConfig.getSetting(ProcessingConfig.SHOW_CRS_DEF) and authid is not None:
layerName = u"{} [{}]".format(layer.name(), authid)
else:
layerName = layer.name()
extents.append(layerName)
extentsDict[layerName] = {"extent": layer.extent(), "authid": authid}
(item, ok) = QInputDialog.getItem(self, self.tr("Select extent"), self.tr("Use extent from"), extents, False)
if ok:
self.setValueFromRect(extentsDict[item]["extent"])
if extentsDict[item]["authid"] != iface.mapCanvas().mapSettings().destinationCrs().authid():
iface.messageBar().pushMessage(
self.tr("Warning"),
self.tr(
"The projection of the chosen layer is not the same as canvas projection! The selected extent might not be what was intended."
),
QgsMessageBar.WARNING,
8,
)
def useLayerExtent(self):
CANVAS_KEY = 'Use canvas extent'
extentsDict = {}
extentsDict[CANVAS_KEY] = {
"extent": iface.mapCanvas().extent(),
"authid":
iface.mapCanvas().mapSettings().destinationCrs().authid()
}
extents = [CANVAS_KEY]
layers = QgsProcessingUtils.compatibleLayers(QgsProject.instance())
for layer in layers:
authid = layer.crs().authid()
if ProcessingConfig.getSetting(ProcessingConfig.SHOW_CRS_DEF) \
and authid is not None:
layerName = u'{} [{}]'.format(layer.name(), authid)
else:
layerName = layer.name()
extents.append(layerName)
extentsDict[layerName] = {
"extent": layer.extent(),
"authid": authid
}
(item, ok) = QInputDialog.getItem(self, self.tr('Select Extent'),
self.tr('Use extent from'), extents,
False)
if ok:
self.setValueFromRect(
QgsReferencedRectangle(
extentsDict[item]["extent"],
QgsCoordinateReferenceSystem(extentsDict[item]["authid"])))
def postProcessAlgorithm(self, context, feedback):
input_layer = QgsProcessingUtils.mapLayerFromString(
self.parameters[self.INPUT], context)
processed_layer = QgsProcessingUtils.mapLayerFromString(
self.dest_id, context)
added_fieldnames = [
fieldname for fieldname in processed_layer.fields().names()
if fieldname not in input_layer.fields().names()
]
if len(added_fieldnames) > 1:
style_by = QInputDialog.getItem(iface.mainWindow(),
"Style output by",
"Field",
added_fieldnames,
editable=False)[0]
else:
style_by = added_fieldnames[0]
LoadOutputAsLayerDialog.style_maps(processed_layer, style_by, iface)
# NOTE: the user might use the following lines after calling the
# algorithm from python:
# QgsProject.instance().addMapLayer(processed_layer)
# iface.setActiveLayer(processed_layer)
# iface.zoomToActiveLayer()
return {self.OUTPUT: processed_layer}
def useLayerExtent(self):
CANVAS_KEY = 'Use canvas extent'
extentsDict = {}
extentsDict[CANVAS_KEY] = {
"extent": iface.mapCanvas().extent(),
"authid":
iface.mapCanvas().mapSettings().destinationCrs().authid()
}
extents = [CANVAS_KEY]
layers = QgsProcessingUtils.compatibleLayers(QgsProject.instance())
for layer in layers:
authid = layer.crs().authid()
if ProcessingConfig.getSetting(ProcessingConfig.SHOW_CRS_DEF) \
and authid is not None:
layerName = u'{} [{}]'.format(layer.name(), authid)
else:
layerName = layer.name()
extents.append(layerName)
extentsDict[layerName] = {
"extent": layer.extent(),
"authid": authid
}
(item, ok) = QInputDialog.getItem(self, self.tr('Select extent'),
self.tr('Use extent from'), extents,
False)
if ok:
self.setValueFromRect(extentsDict[item]["extent"])
if extentsDict[item]["authid"] != iface.mapCanvas().mapSettings(
).destinationCrs().authid():
iface.messageBar().pushMessage(
self.tr("Warning"),
self.
tr("The projection of the chosen layer is not the same as canvas projection! The selected extent might not be what was intended."
), QgsMessageBar.WARNING, 8)
def linkFeatureManyToManyPolymorphic(self):
nmRelations = dict()
for relation in self._polymorphicRelation.generateRelations():
nmRelations[relation.referencedLayer().name()] = relation
layerName, ok = QInputDialog.getItem(self,
self.tr("Please selct a layer"),
self.tr("Layer:"),
nmRelations.keys())
if not ok:
return
nmRelation = nmRelations[layerName]
selectionDlg = QgsFeatureSelectionDlg(nmRelation.referencedLayer(),
self.editorContext(), self)
selectionDlg.setWindowTitle(
self.tr("Please select the features to link. Layer: {0}").format(
layerName))
if not selectionDlg.exec():
return
# Fields of the linking table
fields = self.relation().referencingLayer().fields()
linkAttributes = dict()
linkAttributes[fields.indexFromName(
self._polymorphicRelation.referencedLayerField(
))] = self._polymorphicRelation.layerRepresentation(
nmRelation.referencedLayer())
for key in self.relation().fieldPairs():
linkAttributes[fields.indexOf(key)] = self.feature().attribute(
self.relation().fieldPairs()[key])
# Expression context for the linking table
context = self.relation().referencingLayer().createExpressionContext()
featureIterator = nmRelation.referencedLayer().getFeatures(
QgsFeatureRequest().setFilterFids(
selectionDlg.selectedFeatures()).setSubsetOfAttributes(
nmRelation.referencedFields()))
relatedFeature = QgsFeature()
newFeatures = []
while featureIterator.nextFeature(relatedFeature):
for key in nmRelation.fieldPairs():
linkAttributes[fields.indexOf(key)] = relatedFeature.attribute(
nmRelation.fieldPairs()[key])
linkFeature = QgsVectorLayerUtils.createFeature(
self.relation().referencingLayer(), QgsGeometry(),
linkAttributes, context)
newFeatures.append(linkFeature)
self.relation().referencingLayer().addFeatures(newFeatures)
ids = []
for feature in newFeatures:
ids.append(feature.id())
self.relation().referencingLayer().selectByIds(ids)
def pick_item(self, title, message, parent=None, *items):
"""Getting item from list of items."""
parent = parent if parent is not None else self.iface.mainWindow()
item, accept = QInputDialog.getItem(parent,
title,
message,
items,
editable=False)
if accept is False:
return None
return item
def layerToPyrat():
"""Imports a QGIS-Layer into PyRAT"""
layers = list()
for layer in QgsProject.instance().layerTreeRoot().layerOrder():
# 1: QgsMapLayer.LayerType.RasterLayer
if layer.type() == 1:
layers.append(layer.name())
layername, s = QInputDialog.getItem(
iface.mainWindow(),
"Select a layer",
"Select a layer to export to PyRAT:",
layers,
editable=False)
if not s:
return
layer = QgsProject.instance().mapLayersByName(layername)[0]
dataProv = layer.dataProvider()
extent = dataProv.extent()
rows = layer.height()
cols = layer.width()
block = dataProv.block(1, extent, cols, rows)
arr = np.frombuffer(block.data(),
dtype=qgis_types[block.dataType()]).reshape(
(rows, cols))
pyratlayer = pyrat.adddata(arr)
# Add metadata to the PyRAT-Layer
description = layer.crs().description()
meta = {
"info": layer.name(),
"geo_min_east": extent.xMinimum(),
# Subtract 1 due to QGIS inclusive minimum
"geo_min_north": extent.yMinimum() - 1,
"geo_ps_east": layer.rasterUnitsPerPixelX(),
"geo_ps_north": layer.rasterUnitsPerPixelY()
}
if description.startswith('WGS 84 / UTM zone '):
zone = int(description[:-1].rsplit(" ", 1)[1])
if description[-1] == "S":
zone = -zone
meta["geo_projection"] = 1
meta["geo_zone"] = zone
pyrat.setmeta(meta)
ViewerToQGISInterface.display[pyratlayer] = {
'scaling': 'min->max',
'bwlayer': pyratlayer,
'colour': False
}
PyRATBridge.layerTreeWidget.redraw()
def show_template_help(self):
'''
let the user select a template type in a dialog and show the associated
pdf help file
'''
types = MarketTemplate.template_types.keys()
typ, ok = QInputDialog.getItem(self.ui, 'Ausfüllhilfe anzeigen',
'Dateiformat', types, 0, False)
if ok:
fn = os.path.join(self.settings.HELP_PATH,
MarketTemplate.template_types[typ][1])
open_file(fn)
def save_query(self):
"""Save a query in a preset."""
properties = self.gather_values()
# Make the query
query_factory = QueryFactory(
type_multi_request=properties['type_multi_request'],
query_type=properties['query_type'],
key=properties['key'],
value=properties['value'],
area=properties['place'],
around_distance=properties['distance'],
osm_objects=properties['osm_objects'],
timeout=properties['timeout'],
print_mode=properties['metadata']
)
query = query_factory.make(QueryLanguage.OQL)
description = query_factory.friendly_message()
q_manage = QueryManagement(
query=query,
name=properties['layer_name'],
description=description,
advanced=False,
type_multi_request=properties['type_multi_request'],
keys=properties['key'],
values=properties['value'],
area=properties['place'],
bbox=properties['bbox'],
output_geometry_types=properties['outputs'],
output_directory=properties['output_directory'],
output_format=properties['output_format']
)
if self.existing_preset:
preset_folder = query_preset()
presets = filter(
lambda folder: os.path.isdir(join(preset_folder, folder)), os.listdir(preset_folder))
chosen_preset = QInputDialog.getItem(
self.dialog, tr('Add in an existing preset'),
tr('Please select the preset in which the query will be added:'),
presets, editable=False
)
if chosen_preset[1]:
q_manage.add_query_in_preset(chosen_preset[0])
else:
q_manage.add_preset(properties['layer_name'])
self.dialog.external_panels[Panels.MapPreset].update_personal_preset_view()
item = self.dialog.menu_widget.item(self.dialog.preset_menu_index)
self.dialog.menu_widget.setCurrentItem(item)
def useLayerExtent(self):
CANVAS_KEY = 'Use canvas extent'
extentsDict = {}
extentsDict[CANVAS_KEY] = {"extent": iface.mapCanvas().extent(),
"authid": iface.mapCanvas().mapSettings().destinationCrs().authid()}
extents = [CANVAS_KEY]
for layer in QgsProject.instance().mapLayers().values():
authid = layer.crs().authid()
layerName = layer.name()
extents.append(layerName)
extentsDict[layerName] = {"extent": layer.extent(), "authid": authid}
(item, ok) = QInputDialog.getItem(self, self.tr('Select extent'),
self.tr('Use extent from'), extents, False)
if ok:
self.setValue(extentsDict[item]["extent"], extentsDict[item]['authid'])
def addWMS(self):
if self.wms == None: return
crs = self.gh.getGetMapCrs(self.iface).authid()
if crs != 'EPSG:31370' or crs != 'EPSG:3857' or crs != 'EPSG:3043':
crs = 'EPSG:31370'
try:
lyrs = getWmsLayerNames(self.wms, self.proxy)
except:
self.bar.pushMessage("Error", str(sys.exc_info()[1]), level=Qgis.Critical, duration=10)
return
if len(lyrs) == 0:
self.bar.pushMessage("WMS",
QCoreApplication.translate("geopunt4QgisDataCatalog",
"Kan geen lagen vinden in: %s" % self.wms),
level=Qgis.Warning, duration=10)
return
elif len(lyrs) == 1:
layerTitle = lyrs[0][1]
else:
layerTitle, accept = QInputDialog.getItem(self, "WMS toevoegen",
"Kies een laag om toe te voegen", [n[1] for n in lyrs],
editable=0)
if not accept: return
layerName = [n[0] for n in lyrs if n[1] == layerTitle][0]
style = [n[2] for n in lyrs if n[1] == layerTitle][0]
if not style: style = ""
url = self.wms.split('?')[0]
if crs != 'EPSG:31370' or crs != 'EPSG:3857':
crs = 'EPSG:31370'
wmsUrl = "contextualWMSLegend=0&dpiMode=7&url=%s&layers=%s&format=image/png&styles=%s&crs=%s" % (
url, layerName, style, crs)
try:
rlayer = QgsRasterLayer(wmsUrl, layerTitle, 'wms')
if rlayer.isValid():
QgsProject.instance().addMapLayer(rlayer)
else:
self.bar.pushMessage("Error",
QCoreApplication.translate("geopunt4QgisDataCatalog", "Kan WMS niet laden"),
level=Qgis.Critical, duration=10)
except:
self.bar.pushMessage("Error", str(sys.exc_info()[1]), level=Qgis.Critical, duration=10)
return
def useLayerExtent(self):
extentsDict = {}
extents = []
layers = QgsProcessingUtils.compatibleLayers(QgsProject.instance())
for layer in layers:
authid = layer.crs().authid()
if ProcessingConfig.getSetting(ProcessingConfig.SHOW_CRS_DEF) \
and authid is not None:
layerName = u'{} [{}]'.format(layer.name(), authid)
else:
layerName = layer.name()
extents.append(layerName)
extentsDict[layerName] = {"extent": layer.extent(), "authid": authid}
(item, ok) = QInputDialog.getItem(self, self.tr('Select Extent'),
self.tr('Use extent from'), extents, 0, False)
if ok:
self.setValueFromRect(QgsReferencedRectangle(extentsDict[item]["extent"], QgsCoordinateReferenceSystem(extentsDict[item]["authid"])))
def chooseLayerForRemoval(self, iface, mdl):
if mdl.rowCount() < 2:
if mdl.rowCount() == 1:
return 0
return None
list1 = []
for i in range(0, mdl.rowCount()):
list1.append(str(i + 1) + " : " + mdl.item(i, 2).data(Qt.EditRole))
testqt, ok = QInputDialog.getItem(iface.mainWindow(), "Layer selector",
"Choose the Layer", list1, False)
if ok:
for i in range(0, mdl.rowCount()):
if testqt == (str(i + 1) + " : " +
mdl.item(i, 2).data(Qt.EditRole)):
return i
return None
def accept(self):
try:
nodata = self.ui.IDC_tbNoDataExport.text()
self.settings.nodata_value = int(nodata) if nodata != "" else None
QgsMessageLog.logMessage(
"Maindlg: nodata: {0}".format(self.settings.nodata_value),
"VoGis", Qgis.Info)
if self.settings.onlyHektoMode is True and self.settings.mapData.rasters.count(
) > 0:
self.settings.onlyHektoMode = False
if self.settings.onlyHektoMode is False:
if self.settings.mapData.rasters.count() < 1:
retVal = QMessageBox.warning(
self.iface.mainWindow(), "VoGIS-Profiltool",
QApplication.translate(
"code",
"Keine Rasterebene vorhanden oder sichtbar! Nur hektometrieren?"
), QMessageBox.Yes | QMessageBox.No, QMessageBox.Yes)
if retVal == QMessageBox.No:
return
else:
self.settings.onlyHektoMode = True
self.settings.createHekto = True
if self.__getSettingsFromGui() is False:
return
if self.settings.onlyHektoMode is False:
if len(self.settings.mapData.rasters.selectedRasters()) < 1:
QMessageBox.warning(
self.iface.mainWindow(), "VoGIS-Profiltool",
QApplication.translate("code",
"Kein Raster selektiert!"))
return
QgsMessageLog.logMessage(
"modeLine!=line: {0}".format(
self.settings.modeLine != enumModeLine.line), "VoGis",
Qgis.Info)
QgsMessageLog.logMessage(
"customLine is None: {0}".format(
self.settings.mapData.customLine is None), "VoGis",
Qgis.Info)
if self.settings.modeLine != enumModeLine.line and self.settings.mapData.customLine is None:
QMessageBox.warning(
self.iface.mainWindow(), "VoGIS-Profiltool",
QApplication.translate("code",
"Keine Profillinie vorhanden!"))
return
if len(self.settings.mapData.polygons.selected_polygons()
) > 0 and len(
self.settings.mapData.rasters.selectedRasters()) > 1:
raster_names = list(
raster.name for raster in
self.settings.mapData.rasters.selectedRasters())
sel_raster, ok_clicked = QInputDialog.getItem(
self.iface.mainWindow(), "DHM?",
"Welches DHM soll zur Flächenverschneidung verwendet werden?",
raster_names, 0, False)
if ok_clicked is False:
return
self.settings.intersection_dhm_idx = raster_names.index(
sel_raster)
QApplication.setOverrideCursor(Qt.WaitCursor)
create_profile = CreateProfile(self.iface, self.settings)
thread = QThread(self)
create_profile.moveToThread(thread)
create_profile.finished.connect(self.profiles_finished)
create_profile.error.connect(self.profiles_error)
create_profile.progress.connect(self.profiles_progress)
thread.started.connect(create_profile.create)
thread.start(QThread.LowestPriority)
self.thread = thread
self.create_profile = create_profile
self.ui.buttonBox.button(QDialogButtonBox.Ok).setEnabled(False)
except:
QApplication.restoreOverrideCursor()
ex = "{0}".format(traceback.format_exc())
msg = "Unexpected ERROR:\n\n{0}".format(ex[:2000])
QMessageBox.critical(self.iface.mainWindow(), "VoGIS-Profiltool",
msg)
def accept(self):
try:
nodata = self.ui.IDC_tbNoDataExport.text()
self.settings.nodata_value = int(nodata) if nodata != "" else None
QgsMessageLog.logMessage("Maindlg: nodata: {0}".format(self.settings.nodata_value), "VoGis", Qgis.Info)
if self.settings.onlyHektoMode is True and self.settings.mapData.rasters.count() > 0:
self.settings.onlyHektoMode = False
if self.settings.onlyHektoMode is False:
if self.settings.mapData.rasters.count() < 1:
retVal = QMessageBox.warning(self.iface.mainWindow(),
"VoGIS-Profiltool",
QApplication.translate("code", "Keine Rasterebene vorhanden oder sichtbar! Nur hektometrieren?"),
QMessageBox.Yes | QMessageBox.No,
QMessageBox.Yes)
if retVal == QMessageBox.No:
return
else:
self.settings.onlyHektoMode = True
self.settings.createHekto = True
if self.__getSettingsFromGui() is False:
return
if self.settings.onlyHektoMode is False:
if len(self.settings.mapData.rasters.selectedRasters()) < 1:
QMessageBox.warning(self.iface.mainWindow(),
"VoGIS-Profiltool",
QApplication.translate("code", "Kein Raster selektiert!"))
return
QgsMessageLog.logMessage("modeLine!=line: {0}".format(self.settings.modeLine != enumModeLine.line), "VoGis", Qgis.Info)
QgsMessageLog.logMessage("customLine is None: {0}".format(self.settings.mapData.customLine is None), "VoGis", Qgis.Info)
if self.settings.modeLine != enumModeLine.line and self.settings.mapData.customLine is None:
QMessageBox.warning(self.iface.mainWindow(),
"VoGIS-Profiltool",
QApplication.translate("code", "Keine Profillinie vorhanden!"))
return
if len(self.settings.mapData.polygons.selected_polygons()) > 0 and len(self.settings.mapData.rasters.selectedRasters()) > 1:
raster_names = list(raster.name for raster in self.settings.mapData.rasters.selectedRasters())
sel_raster, ok_clicked = QInputDialog.getItem(
self.iface.mainWindow(),
"DHM?",
"Welches DHM soll zur Flächenverschneidung verwendet werden?",
raster_names,
0,
False
)
if ok_clicked is False:
return
self.settings.intersection_dhm_idx = raster_names.index(sel_raster)
QApplication.setOverrideCursor(Qt.WaitCursor)
create_profile = CreateProfile(self.iface, self.settings)
thread = QThread(self)
create_profile.moveToThread(thread)
create_profile.finished.connect(self.profiles_finished)
create_profile.error.connect(self.profiles_error)
create_profile.progress.connect(self.profiles_progress)
thread.started.connect(create_profile.create)
thread.start(QThread.LowestPriority)
self.thread = thread
self.create_profile = create_profile
self.ui.buttonBox.button(QDialogButtonBox.Ok).setEnabled(False)
except:
QApplication.restoreOverrideCursor()
ex = "{0}".format(traceback.format_exc())
msg = "Unexpected ERROR:\n\n{0}".format(ex[:2000])
QMessageBox.critical(self.iface.mainWindow(), "VoGIS-Profiltool", msg)
def syncLayer(layer):
tracking = getTrackingInfo(layer)
repo = Repository(tracking.repoUrl)
filename, layername = namesFromLayer(layer)
con = sqlite3.connect(filename)
cursor = con.cursor()
cursor.execute("SELECT * FROM %s_audit;" % layername)
changes = bool(cursor.fetchall())
cursor.close()
con.close()
if changes:
con = sqlite3.connect(filename)
cursor = con.cursor()
beforeAttrs = set(v[1]
for v in cursor.execute("PRAGMA table_info('%s');" %
layername))
afterAttrs = set(
v[1] for v in cursor.execute("PRAGMA table_info('%s_audit');" %
layername)
if v[1] not in ["audit_timestamp", "audit_op"])
cursor.close()
con.close()
if beforeAttrs != afterAttrs:
ret = QMessageBox.warning(
iface.mainWindow(), "Cannot commit changes to repository",
"The structure of attributes table has been modified.\n"
"This type of change is not supported by GeoGig.",
QMessageBox.Yes)
return
user, email = config.getUserInfo()
if user is None:
return
dlg = CommitDialog(repo, layername)
dlg.exec_()
if dlg.branch is None:
return
if dlg.branch not in repo.branches():
commitId = getCommitId(layer)
repo.createbranch(commitId, dlg.branch)
mergeCommitId, importCommitId, conflicts, featureIds = repo.importgeopkg(
layer, dlg.branch, dlg.message, user, email, True)
if conflicts:
ret = QMessageBox.warning(
iface.mainWindow(), "Error while syncing",
"There are conflicts between local and remote changes.\n"
"Do you want to continue and fix them?",
QMessageBox.Yes | QMessageBox.No)
if ret == QMessageBox.No:
repo.closeTransaction(conflicts[0].transactionId)
return
solved, resolvedConflicts = solveConflicts(conflicts)
if not solved:
repo.closeTransaction(conflicts[0].transactionId)
return
for conflict, resolution in zip(conflicts,
list(resolvedConflicts.values())):
if resolution == ConflictDialog.LOCAL:
conflict.resolveWithLocalVersion()
elif resolution == ConflictDialog.REMOTE:
conflict.resolveWithRemoteVersion()
elif resolution == ConflictDialog.DELETE:
conflict.resolveDeletingFeature()
else:
conflict.resolveWithNewFeature(resolution)
repo.commitAndCloseMergeAndTransaction(user, email,
"Resolved merge conflicts",
conflicts[0].transactionId)
updateFeatureIds(repo, layer, featureIds)
try:
applyLayerChanges(repo, layer, importCommitId, mergeCommitId)
except:
QgsMessageLog.logMessage(
"Database locked while syncing. Using full layer checkout instead",
level=QgsMessageLog.CRITICAL)
repo.checkoutlayer(tracking.geopkg, layername, None, mergeCommitId)
commitdialog.suggestedMessage = ""
else:
branches = []
for branch in repo.branches():
trees = repo.trees(branch)
if layername in trees:
branches.append(branch)
branch, ok = QInputDialog.getItem(iface.mainWindow(), "Sync",
"Select branch to update from",
branches, 0, False)
if not ok:
return
commitId = getCommitId(layer)
headCommitId = repo.revparse(branch)
applyLayerChanges(repo, layer, commitId, headCommitId)
layer.reload()
layer.triggerRepaint()
repoWatcher.repoChanged.emit(repo)
iface.messageBar().pushMessage("GeoGig",
"Layer has been correctly synchronized",
level=QgsMessageBar.INFO,
duration=5)
repoWatcher.layerUpdated.emit(layer)
