def viewMetadata(self, layer_id):
server = manager.getMetadataServer(self.comboMetadataServer.currentText())
if not server:
return
layer = getLayerById(layer_id)
uuid = uuidForLayer(layer)
server.openMetadata(uuid)
def unpublishMetadata(self, layer_id):
server = manager.getMetadataServer(self.comboMetadataServer.currentText())
if not server:
return False
uuid = uuidForLayer(getLayerById(layer_id))
server.deleteMetadata(uuid)
self.updateLayerIsMetadataPublished(layer_id, None)
return True
def viewWms(self, layer_id):
server = manager.getGeodataServer(self.comboGeodataServer.currentText())
if not server:
return
layer = getLayerById(layer_id)
_, name = getLayerTitleAndName(layer)
bbox = layer.extent()
if bbox.isEmpty():
bbox.grow(1)
self.previewWebService(server, [name], bbox, layer.crs().authid())
def unpublishData(self, layer_id):
server = manager.getGeodataServer(self.comboGeodataServer.currentText())
if not server:
return
layer = getLayerById(layer_id)
_, name = getLayerTitleAndName(layer)
if server.deleteLayer(name):
# Deletion was successful: silently try to remove style (should have been removed already)
server.deleteStyle(name)
# Mark layer as deleted
self.updateLayerIsDataPublished(layer_id, None)
def updateOnlineLayersPublicationStatus(self, data: bool = True, metadata: bool = True) -> bool:
""" Validates online tab servers and updates layer status. """
if self.tabOnOffline.currentWidget() != self.tabOnline:
# Current tab is not the online publish tab
return True
can_publish = True
data_server = manager.getGeodataServer(self.comboGeodataServer.currentText())
metadata_server = manager.getMetadataServer(self.comboMetadataServer.currentText())
errors = set()
if data:
self.comboGeodataServer.setStyleSheet("QComboBox { }")
if data_server and not data_server.testConnection(errors):
self.comboGeodataServer.setStyleSheet("QComboBox { border: 2px solid red; }")
can_publish = False
if metadata:
self.comboMetadataServer.setStyleSheet("QComboBox { }")
if metadata_server and not metadata_server.testConnection(errors):
self.comboMetadataServer.setStyleSheet("QComboBox { border: 2px solid red; }")
can_publish = False
# Show errors (if there are any)
for e in errors:
self.showErrorBar("Error", e)
for i in range(self.listLayers.count()):
item = self.listLayers.item(i)
widget = self.listLayers.itemWidget(item)
layer = getLayerById(widget.id)
if data:
server = None
if data_server:
self.isDataPublished[layer.id()] = self.isDataOnServer(layer)
server = data_server if self.isDataPublished.get(layer.id()) else None
widget.setDataPublished(server)
if metadata:
server = None
if metadata_server:
self.isMetadataPublished[layer.id()] = self.isMetadataOnServer(layer)
server = metadata_server if self.isMetadataPublished[layer.id()] else None
widget.setMetadataPublished(server)
can_publish = can_publish and self.listLayers.count()
return can_publish
def populateTree(self):
for lyr_name in (lyr_utils.getLayerById(id_).name() for id_ in self.layer_ids):
item = QTreeWidgetItem()
item.setText(0, lyr_name)
subitem = QTreeWidgetItem()
subitem.setText(0, "Publish symbology")
subitem.setIcon(0, SYMBOLOGY_ICON)
item.addChild(subitem)
subitem = QTreeWidgetItem()
subitem.setText(0, "Publish data")
subitem.setIcon(0, DATA_ICON)
item.addChild(subitem)
subitem = QTreeWidgetItem()
subitem.setText(0, "Publish metadata")
subitem.setIcon(0, METADATA_ICON)
item.addChild(subitem)
self.treeWidget.addTopLevelItem(item)
item.setExpanded(False)
item = QTreeWidgetItem()
item.setText(0, "Create layer groups")
item.setIcon(0, GROUPS_ICON)
self.treeWidget.addTopLevelItem(item)
QCoreApplication.processEvents()
def run(self):
def publishLayer(lyr, lyr_name):
fields = None
if lyr.type() == lyr.VectorLayer:
fields = [
_name
for _name, publish in self.field_map[lyr.id()].items()
if publish
]
self.geodata_server.publishLayer(lyr, fields)
if self.metadata_server is not None:
metadata_uuid = uuidForLayer(lyr)
md_url = self.metadata_server.metadataUrl(metadata_uuid)
self.geodata_server.setLayerMetadataLink(lyr_name, md_url)
try:
validator = QgsNativeMetadataValidator()
# FIXME: remove or improve this
# DONOTALLOW = 0
ALLOW = 1
ALLOWONLYDATA = 2
allow_without_md = ALLOW # pluginSetting("allowWithoutMetadata")
if self.geodata_server is not None:
self.geodata_server.prepareForPublishing(self.only_symbology)
self.results = {}
for i, layer_id in enumerate(self.layer_ids):
if self.isCanceled():
return False
warnings, errors = [], []
self.setProgress(i * 100 / len(self.layer_ids))
layer = lyr_utils.getLayerById(layer_id)
name, safe_name = lyr_utils.getLayerTitleAndName(layer)
if not lyr_utils.hasValidLayerName(layer):
try:
warnings.append(
f"Layer name '{name}' contains characters that may cause issues"
)
except UnicodeError:
warnings.append(
"Layer name contains characters that may cause issues"
)
md_valid, _ = validator.validate(layer.metadata())
if self.geodata_server is not None:
self.geodata_server.resetLogIssues()
# Publish style
self.stepStarted.emit(layer_id, SYMBOLOGY)
try:
self.geodata_server.publishStyle(layer)
except:
errors.append(traceback.format_exc())
self.stepFinished.emit(layer_id, SYMBOLOGY)
if self.only_symbology:
# Skip data publish if "only symbology" was checked
self.stepSkipped.emit(layer_id, DATA)
else:
# Publish data
self.stepStarted.emit(layer_id, DATA)
try:
if md_valid or allow_without_md in (ALLOW,
ALLOWONLYDATA):
publishLayer(layer, safe_name)
else:
self.stepStarted.emit(layer_id, DATA)
if md_valid or allow_without_md in (
ALLOW, ALLOWONLYDATA):
publishLayer(layer, safe_name)
else:
self.geodata_server.logError(
f"Layer '{name}' has invalid metadata. "
f"Layer was not published")
self.stepFinished.emit(layer_id, DATA)
except:
errors.append(traceback.format_exc())
self.stepFinished.emit(layer_id, DATA)
else:
# No geodata server selected: skip layer data and symbology
self.stepSkipped.emit(layer_id, SYMBOLOGY)
self.stepSkipped.emit(layer_id, DATA)
if self.metadata_server is not None:
# User selected metadata server: publish metadata
try:
self.metadata_server.resetLogIssues()
if md_valid or allow_without_md == ALLOW:
wms = None
wfs = None
full_name = None
if self.geodata_server is not None:
full_name = self.geodata_server.fullLayerName(
safe_name)
wms = self.geodata_server.getWmsUrl()
if layer.type() == layer.VectorLayer:
wfs = self.geodata_server.getWfsUrl()
self.autofillMetadata(layer)
self.stepStarted.emit(layer_id, METADATA)
self.metadata_server.publishLayerMetadata(
layer, wms, wfs, full_name)
self.stepFinished.emit(layer_id, METADATA)
else:
self.metadata_server.logError(
f"Layer '{name}' has invalid metadata. "
f"Metadata was not published")
except:
errors.append(traceback.format_exc())
else:
self.stepSkipped.emit(layer_id, METADATA)
# Collect all layer-specific errors and warnings (if any)
if self.geodata_server is not None:
w, e = self.geodata_server.getLogIssues()
warnings.extend(w)
errors.extend(e)
if self.metadata_server is not None:
w, e = self.metadata_server.getLogIssues()
warnings.extend(w)
errors.extend(e)
self.results[name] = (set(warnings), set(errors))
# Create layer groups (if any)
if self.geodata_server is not None:
self.stepStarted.emit(None, GROUPS)
try:
# FIXME (did this ever work?)
self.geodata_server.createGroups(self._layerGroups(),
self.layer_ids)
except Exception as err:
# TODO: figure out where to properly put a warning or error message for this
feedback.logError(f"Could not create layer groups: {err}")
finally:
try:
# Call closePublishing(): for GeoServer, this will set up vector tiles, if enabled
self.geodata_server.closePublishing()
except Exception as err:
feedback.logError(
f"Failed to finalize publish task: {err}")
self.stepFinished.emit(None, GROUPS)
else:
self.stepSkipped.emit(None, GROUPS)
return True
except Exception:
self.exc_type, _, _ = sys.exc_info()
self.exception = traceback.format_exc()
return False