def add_authentication(self):
"""Slot for when the add auth button is clicked."""
if qgis_version() >= 21200:
from qgis.gui import QgsAuthConfigSelect
dlg = QDialog(self)
dlg.setWindowTitle(self.tr("Select Authentication"))
layout = QVBoxLayout(dlg)
acs = QgsAuthConfigSelect(dlg)
if self.line_edit_auth_id.text():
acs.setConfigId(self.line_edit_auth_id.text())
layout.addWidget(acs)
button_box = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel,
Qt.Horizontal,
dlg)
layout.addWidget(button_box)
button_box.accepted.connect(dlg.accept)
button_box.rejected.connect(dlg.close)
dlg.setLayout(layout)
dlg.setWindowModality(Qt.WindowModal)
if dlg.exec_():
self.line_edit_auth_id.setText(acs.configId())
del dlg
def add_authentication(self):
"""Slot for when the add auth button is clicked."""
if qgis_version() >= 21200:
from qgis.gui import QgsAuthConfigSelect
dlg = QDialog(self)
dlg.setWindowTitle(self.tr("Select Authentication"))
layout = QVBoxLayout(dlg)
acs = QgsAuthConfigSelect(dlg)
if self.line_edit_auth_id.text():
acs.setConfigId(self.line_edit_auth_id.text())
layout.addWidget(acs)
button_box = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel,
Qt.Horizontal,
dlg)
layout.addWidget(button_box)
button_box.accepted.connect(dlg.accept)
button_box.rejected.connect(dlg.close)
dlg.setLayout(layout)
dlg.setWindowModality(Qt.WindowModal)
if dlg.exec_():
self.line_edit_auth_id.setText(acs.configId())
del dlg
def authcfg_edit(self):
dlg = QDialog(None)
dlg.setWindowTitle(self.util.tr("Select Authentication"))
layout = QtGui.QVBoxLayout(dlg)
acs = QgsAuthConfigSelect(dlg)
if self.IDC_leAuthCfg.text():
acs.setConfigId(self.IDC_leAuthCfg.text())
layout.addWidget(acs)
buttonbox = QtGui.QDialogButtonBox(
QtGui.QDialogButtonBox.Ok | QtGui.QDialogButtonBox.Cancel,
Qt.Horizontal, dlg
)
layout.addWidget(buttonbox)
buttonbox.accepted.connect(dlg.accept)
buttonbox.rejected.connect(dlg.close)
dlg.setLayout(layout)
dlg.setWindowModality(Qt.WindowModal)
if dlg.exec_():
self.IDC_leAuthCfg.setText(acs.configId())
self.cc.authcfg = acs.configId()
class AuthConfigSelectDialog(QDialog):
"""Dialog to select a Authentication config ID from that available in the
QGIS Authentication DB. Select can be restricted to that supported by a
specified and supported provider.
"""
def __init__(self, parent=None, authcfg=None, provider=None):
super(AuthConfigSelectDialog, self).__init__(parent)
self.authcfg = authcfg
#self.resize(600, 350)
self.setWindowFlags(self.windowFlags() | Qt.WindowSystemMenuHint
| Qt.WindowMinMaxButtonsHint)
self.setWindowTitle("Authentication config ID selector")
layout = QVBoxLayout()
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.editor = QgsAuthConfigSelect(self, dataprovider=provider)
self.editor.setConfigId(authcfg)
layout.addWidget(self.editor)
layout.addWidget(buttonBox)
self.setLayout(layout)
buttonBox.accepted.connect(self.okPressed)
buttonBox.rejected.connect(self.cancelPressed)
def okPressed(self):
self.authcfg = self.editor.configId()
self.accept()
def cancelPressed(self):
self.reject()
def __init__(self, parent, server_type):
super().__init__(parent, server_type)
self.setupUi(self)
self.postgisAuth = QgsAuthConfigSelect()
self.postgisAuth.selectedConfigIdChanged.connect(self.setDirty)
self.addAuthWidget()
self.txtPostgisName.textChanged.connect(self.setDirty)
self.txtPostgisServerAddress.textChanged.connect(self.setDirty)
self.txtPostgisPort.textChanged.connect(self.setDirty)
self.txtPostgisSchema.textChanged.connect(self.setDirty)
self.txtPostgisDatabase.textChanged.connect(self.setDirty)
def editAuthCfgId(self):
dlg = QDialog(self)
dlg.setWindowModality(Qt.WindowModal)
layout = QVBoxLayout()
selector = QgsAuthConfigSelect(self)
if self.editAuthCfg.text():
selector.setConfigId(self.editAuthCfg.text())
layout.addWidget(selector)
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Close)
buttonBox.accepted.connect(dlg.accept)
buttonBox.rejected.connect(dlg.reject)
layout.addWidget(buttonBox)
dlg.setLayout(layout)
if dlg.exec_():
self.editAuthCfg.setText(selector.configId())
del dlg
def __init__(self, parent, server_type):
super().__init__(parent, server_type)
self.setupUi(self)
self.mapserverAuth = QgsAuthConfigSelect()
self.mapserverAuth.selectedConfigIdChanged.connect(self.setDirty)
self.addAuthWidget()
self.radioLocalPath.toggled.connect(self.showLocalStorageFields)
self.fileMapserver.setStorageMode(self.fileMapserver.GetDirectory)
self.txtMapserverName.textChanged.connect(self.setDirty)
self.txtMapserverUrl.textChanged.connect(self.setDirty)
self.txtMapserverHost.textChanged.connect(self.setDirty)
self.txtMapserverPort.textChanged.connect(self.setDirty)
self.txtMapserverUrl.textChanged.connect(self.setDirty)
self.txtMapServicesPath.textChanged.connect(self.setDirty)
self.txtProjFolder.textChanged.connect(self.setDirty)
def __init__(self, parent, server_type):
super().__init__(parent, server_type)
self.setupUi(self)
self.geonetworkAuth = QgsAuthConfigSelect()
self.geonetworkAuth.selectedConfigIdChanged.connect(self.setDirty)
self.addAuthWidget()
self.txtGeonetworkName.textChanged.connect(self.setDirty)
self.txtGeonetworkNode.textChanged.connect(self.setDirty)
self.txtGeonetworkUrl.textChanged.connect(self.setDirty)
self.populateProfileCombo()
self.comboMetadataProfile.currentIndexChanged.connect(self.setDirty)
# TODO: implement profile stuff
self.comboMetadataProfile.setVisible(False)
self.labelMetadataProfile.setVisible(False)
def __init__(self, parent, server_type):
super().__init__(parent, server_type)
self.setupUi(self)
self.geoserverAuth = QgsAuthConfigSelect()
self.geoserverAuth.selectedConfigIdChanged.connect(self.setDirty)
self.addAuthWidget()
self.populateStorageCombo()
self.comboStorageType.currentIndexChanged.connect(self.datastoreChanged)
self.btnRefreshDatabases.clicked.connect(partial(self.updateDbServersCombo, True))
self.btnAddDatastore.clicked.connect(self.addPostgisDatastore)
self.txtGeoserverName.textChanged.connect(self.setDirty)
self.txtGeoserverUrl.textChanged.connect(self.setDirty)
self.chkUseOriginalDataSource.stateChanged.connect(self.setDirty)
self.chkUseVectorTiles.stateChanged.connect(self.setDirty)
self.comboGeoserverDatabase.currentIndexChanged.connect(self.setDirty)
# Declare progress dialog
self._pgdialog = None
def __init__(self, parent=None, authcfg=None, provider=None):
super(AuthConfigSelectDialog, self).__init__(parent)
self.authcfg = authcfg
#self.resize(600, 350)
self.setWindowFlags(self.windowFlags() | Qt.WindowSystemMenuHint
| Qt.WindowMinMaxButtonsHint)
self.setWindowTitle("Authentication config ID selector")
layout = QVBoxLayout()
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.editor = QgsAuthConfigSelect(self, dataprovider=provider)
self.editor.setConfigId(authcfg)
layout.addWidget(self.editor)
layout.addWidget(buttonBox)
self.setLayout(layout)
buttonBox.accepted.connect(self.okPressed)
buttonBox.rejected.connect(self.cancelPressed)
def __init__(self, plugin):
QDialog.__init__(self)
self.setupUi(self)
self.plugin = plugin
self.settings = plugin.settings
self.settings.loadSettings()
self.leSERVICE.setText(self.settings.service)
self.leHOST.setText(self.settings.host)
self.lePORT.setText(self.settings.port)
self.leDBNAME.setText(self.settings.dbname)
self.leSCHEMA.setText(self.settings.schema)
self.leUID.setText(self.settings.uid)
self.lePWD.setText(self.settings.pwd)
self.cbxSignaturkatalog.setEnabled(False)
if hasattr(qgis.gui, 'QgsAuthConfigSelect'):
self.authCfgSelect = QgsAuthConfigSelect(self, "postgres")
self.tabWidget.insertTab(1, self.authCfgSelect, "Konfigurationen")
authcfg = self.settings.authcfg
if authcfg:
self.tabWidget.setCurrentIndex(1)
self.authCfgSelect.setConfigId(authcfg)
self.leUMNPath.setText(self.settings.umnpath)
self.pbUMNBrowse.clicked.connect(self.browseUMNPath)
self.leUMNTemplate.setText(self.settings.umntemplate)
self.teFussnote.setPlainText(self.settings.footnote)
self.loadModels(False)
self.bb.accepted.connect(self.accept)
self.bb.rejected.connect(self.reject)
self.bb.addButton("Modelle laden", QDialogButtonBox.ActionRole).clicked.connect(self.loadModels)
self.bb.addButton("Layer einbinden", QDialogButtonBox.ActionRole).clicked.connect(self.loadLayers)
self.restoreGeometry(QSettings("norBIT", "norGIS-ALKIS-Erweiterung").value("confgeom", QByteArray(), type=QByteArray))
def __init__(self, plugin):
QDialog.__init__(self)
self.setupUi(self)
self.plugin = plugin
self.settings = plugin.settings
self.settings.loadSettings()
self.leSERVICE.setText(self.settings.service)
self.leHOST.setText(self.settings.host)
self.lePORT.setText(self.settings.port)
self.leDBNAME.setText(self.settings.dbname)
self.leSCHEMA.setText(self.settings.schema)
self.leUID.setText(self.settings.uid)
self.lePWD.setText(self.settings.pwd)
self.cbxSignaturkatalog.setEnabled(False)
if hasattr(qgis.gui, 'QgsAuthConfigSelect'):
self.authCfgSelect = QgsAuthConfigSelect(self, "postgres")
self.tabWidget.insertTab(1, self.authCfgSelect, "Konfigurationen")
authcfg = self.settings.authcfg
if authcfg:
self.tabWidget.setCurrentIndex(1)
self.authCfgSelect.setConfigId(authcfg)
self.leUMNPath.setText(self.settings.umnpath)
self.pbUMNBrowse.clicked.connect(self.browseUMNPath)
self.leUMNTemplate.setText(self.settings.umntemplate)
self.teFussnote.setPlainText(self.settings.footnote)
self.loadModels(False)
self.bb.accepted.connect(self.accept)
self.bb.rejected.connect(self.reject)
self.bb.addButton("Modelle laden", QDialogButtonBox.ActionRole).clicked.connect(self.loadModels)
self.bb.addButton("Layer einbinden", QDialogButtonBox.ActionRole).clicked.connect(self.loadLayers)
self.restoreGeometry(QSettings("norBIT", "norGIS-ALKIS-Erweiterung").value("confgeom", QByteArray(), type=QByteArray))
def authcfg_edit(self):
dlg = QDialog(None)
dlg.setWindowTitle(self.util.tr("Select Authentication"))
layout = QVBoxLayout(dlg)
acs = QgsAuthConfigSelect(dlg)
if self.IDC_leAuthCfg.text():
acs.setConfigId(self.IDC_leAuthCfg.text())
layout.addWidget(acs)
buttonbox = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel, Qt.Horizontal, dlg)
layout.addWidget(buttonbox)
buttonbox.accepted.connect(dlg.accept)
buttonbox.rejected.connect(dlg.close)
dlg.setLayout(layout)
dlg.setWindowModality(Qt.WindowModal)
if dlg.exec_():
self.IDC_leAuthCfg.setText(acs.configId())
self.cc.auth_cfg = acs.configId()
def addAuthWidgets(self):
self.geoserverAuth = QgsAuthConfigSelect()
self.geoserverAuth.selectedConfigIdChanged.connect(
self._setCurrentServerHasChanges)
layout = QHBoxLayout()
layout.setMargin(0)
layout.addWidget(self.geoserverAuth)
self.geoserverAuthWidget.setLayout(layout)
self.geoserverAuthWidget.setFixedHeight(self.txtGeoserverUrl.height())
self.mapserverAuth = QgsAuthConfigSelect()
self.mapserverAuth.selectedConfigIdChanged.connect(
self._setCurrentServerHasChanges)
layout = QHBoxLayout()
layout.setMargin(0)
layout.addWidget(self.mapserverAuth)
self.mapserverAuthWidget.setLayout(layout)
self.mapserverAuthWidget.setFixedHeight(self.txtGeoserverUrl.height())
self.postgisAuth = QgsAuthConfigSelect()
self.postgisAuth.selectedConfigIdChanged.connect(
self._setCurrentServerHasChanges)
layout = QHBoxLayout()
layout.setMargin(0)
layout.addWidget(self.postgisAuth)
self.postgisAuthWidget.setLayout(layout)
self.postgisAuthWidget.setFixedHeight(self.txtGeoserverUrl.height())
self.cswAuth = QgsAuthConfigSelect()
self.cswAuth.selectedConfigIdChanged.connect(
self._setCurrentServerHasChanges)
layout = QHBoxLayout()
layout.setMargin(0)
layout.addWidget(self.cswAuth)
self.cswAuthWidget.setLayout(layout)
self.cswAuthWidget.setFixedHeight(self.txtGeoserverUrl.height())
self.geocatLiveGeoserverAuth = QgsAuthConfigSelect()
self.geocatLiveGeoserverAuth.selectedConfigIdChanged.connect(
self._setCurrentServerHasChanges)
layout = QHBoxLayout()
layout.setMargin(0)
layout.addWidget(self.geocatLiveGeoserverAuth)
self.geocatLiveGeoserverAuthWidget.setLayout(layout)
self.geocatLiveGeoserverAuthWidget.setFixedHeight(
self.txtGeoserverUrl.height())
self.geocatLiveGeonetworkAuth = QgsAuthConfigSelect()
self.geocatLiveGeonetworkAuth.selectedConfigIdChanged.connect(
self._setCurrentServerHasChanges)
layout = QHBoxLayout()
layout.setMargin(0)
layout.addWidget(self.geocatLiveGeonetworkAuth)
self.geocatLiveGeonetworkAuthWidget.setLayout(layout)
self.geocatLiveGeonetworkAuthWidget.setFixedHeight(
self.txtGeoserverUrl.height())
class MapServerWidget(ServerWidgetBase, BASE, WIDGET):
def __init__(self, parent, server_type):
super().__init__(parent, server_type)
self.setupUi(self)
self.mapserverAuth = QgsAuthConfigSelect()
self.mapserverAuth.selectedConfigIdChanged.connect(self.setDirty)
self.addAuthWidget()
self.radioLocalPath.toggled.connect(self.showLocalStorageFields)
self.fileMapserver.setStorageMode(self.fileMapserver.GetDirectory)
self.txtMapserverName.textChanged.connect(self.setDirty)
self.txtMapserverUrl.textChanged.connect(self.setDirty)
self.txtMapserverHost.textChanged.connect(self.setDirty)
self.txtMapserverPort.textChanged.connect(self.setDirty)
self.txtMapserverUrl.textChanged.connect(self.setDirty)
self.txtMapServicesPath.textChanged.connect(self.setDirty)
self.txtProjFolder.textChanged.connect(self.setDirty)
def createServerInstance(self):
""" Reads the settings form fields and returns a new server instance with these settings. """
try:
port = int(self.txtMapserverPort.text())
except (ValueError, TypeError):
self.parent.logError('Invalid MapServer port specified')
return None
local_storage = self.radioLocalPath.isChecked()
if local_storage:
folder = self.fileMapserver.filePath()
else:
folder = self.txtRemoteFolder.text()
try:
name = self.txtMapserverName.text().strip()
url = self.txtMapserverUrl.text().strip()
if not name:
raise RuntimeError(
f'missing {self.serverType.getLabel()} name')
if not url:
raise RuntimeError(f'missing {self.serverType.getLabel()} URL')
return self.serverType(
name=name,
url=url,
useLocalFolder=local_storage,
folder=folder,
authid=self.mapserverAuth.configId(),
host=self.txtMapserverHost.text().strip(),
port=port,
servicesPath=self.txtMapServicesPath.text().strip(),
projFolder=self.txtProjFolder.text().strip())
except Exception as e:
self.parent.logError(
f"Failed to create {self.serverType.getLabel()} instance: {e}")
return None
def newFromName(self, name: str):
""" Sets the name field and keeps all others empty. """
self.txtMapserverName.setText(name)
self.txtMapserverHost.clear()
self.txtMapserverPort.clear()
self.mapserverAuth.setConfigId(None)
self.txtMapserverUrl.clear()
self.txtMapServicesPath.clear()
self.txtProjFolder.clear()
self.radioLocalPath.setChecked(True)
self.radioFtp.setChecked(False)
self.showLocalStorageFields(True)
def loadFromInstance(self, server):
""" Populates the form fields with the values from the given server instance. """
self.txtMapserverName.setText(server.serverName)
self.fileMapserver.setFilePath(server.folder)
self.txtRemoteFolder.setText(server.folder)
self.txtMapserverHost.setText(server.host)
self.txtMapserverPort.setText(str(server.port))
self.mapserverAuth.setConfigId(server.authId)
self.txtMapserverUrl.setText(server.baseUrl)
self.txtMapServicesPath.setText(server.servicesPath)
self.txtProjFolder.setText(server.projFolder)
self.radioLocalPath.setChecked(server.useLocalFolder)
self.radioFtp.setChecked(not server.useLocalFolder)
self.showLocalStorageFields(server.useLocalFolder)
# After the data has loaded, the form is "clean"
self.setClean()
def addAuthWidget(self):
layout = QHBoxLayout()
layout.setContentsMargins(0, 3, 0, 0)
layout.addWidget(self.mapserverAuth)
self.mapserverAuthWidget.setLayout(layout)
self.mapserverAuthWidget.setFixedHeight(self.txtMapserverUrl.height())
def showLocalStorageFields(self, checked):
self.labelLocalFolder.setVisible(checked)
self.labelRemoteFolder.setVisible(not checked)
self.fileMapserver.setVisible(checked)
self.txtRemoteFolder.setVisible(not checked)
self.labelHost.setVisible(not checked)
self.labelPort.setVisible(not checked)
self.labelMapserverCredentials.setVisible(not checked)
self.txtMapserverHost.setVisible(not checked)
self.txtMapserverPort.setVisible(not checked)
self.mapserverAuthWidget.setVisible(not checked)
self.setDirty()
def __init__(self, iface):
"""Constructor.
:param iface: An interface instance that will be passed to this class
which provides the hook by which you can manipulate the QGIS
application at run time.
:type iface: QgsInterface
"""
# Save reference to the QGIS interface
self.iface = iface
# initialize plugin directory
self.plugin_dir = os.path.dirname(__file__)
# initialize locale
self.MSG_TITLE = self.tr('DHIS2 datafetcher')
locale = QSettings().value('locale/userLocale')[0:2]
self.info('Locale: "{}"'.format(locale))
locale_path = os.path.join(
self.plugin_dir,
'i18n',
'{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
QCoreApplication.installTranslator(self.translator)
else:
self.info('Locale niet gevonden: "{}"'.format(locale_path))
# start a group/dir for all settings
self.SETTINGS_GROUP = self.tr('dhis2datafetcher')
QgsSettings().beginGroup(self.SETTINGS_GROUP, QgsSettings.Plugins)
# Create the dialog (after translation) and keep reference
self.dlg = DHIS2DataFetcherDialog(self.iface.mainWindow())
self.dlg.cb_ou.currentIndexChanged.connect(self.cb_ou_changed)
self.dlg.cb_pe.currentIndexChanged.connect(self.cb_pe_changed)
self.dlg.cb_dx.currentIndexChanged.connect(self.cb_dx_changed)
self.dlg.cb_level.currentIndexChanged.connect(self.cb_level_changed)
self.dlg.btn_load_geodata.clicked.connect(self.load_geodata_in_layer)
self.dlg.btn_new_dataset.clicked.connect(self.new_dataset)
# Replace the placeholder in the dialog with a QgsAuthConfigSelect widget
self.dlg.cmb_profile_select.close() # this apparently also removes the widget??
self.dlg.cmb_profile_select = QgsAuthConfigSelect()
self.dlg.gridLayout.addWidget(self.dlg.cmb_profile_select, 0, 1, 1, 1) # row, col, #rows, #cols
self.dlg.cmb_profile_select.selectedConfigIdChanged.connect(self.selectAuthConfig)
# Declare instance attributes
self.actions = []
self.menu = QMenu(self.tr(u'KIT - DHIS2 Data Fetcher'))
self.iface.pluginMenu().addMenu(self.menu)
self.menu.setIcon(QIcon(':/plugins/DHIS2DataFetcher/icon_kit.png'))
self.toolbar = self.iface.addToolBar(u'DHIS2DataFetcher')
self.toolbar.setObjectName(u'DHIS2DataFetcher')
self.api_url = None # url as defined by user in authorisation profile
self.auth_id = None # authorisation id to be used in nam creation AND vectorlayer creation uri
self.gui_inited = False
self.nam = None # created in gui during authorisation profile choice
self.ou_items = []
self.pe_items = []
self.dx_items = []
# current demo site
self.analytics_url = 'https://play.dhis2.org/2.28/api/'
self.username = '******'
self.password = '******'
self.level = 2
# connect to the iface.projectRead signal to be able to refresh data in a project with a dhis2 layer
self.iface.projectRead.connect(self.update_dhis2_project)
class DistrictSettingsDialog(QDialog):
"""
A dialog used for plugin settings
"""
def __init__(self, parent=None): # pylint: disable=too-many-statements
super().__init__(parent)
self.setWindowTitle(self.tr('Redistrict Plugin | Settings'))
layout = QVBoxLayout()
self.auth_label = QLabel(self.tr('Authentication configuration'))
layout.addWidget(self.auth_label)
self.auth_value = QgsAuthConfigSelect()
layout.addWidget(self.auth_value)
auth_id = get_auth_config_id()
if auth_id:
self.auth_value.setConfigId(auth_id)
layout.addWidget(QLabel(self.tr('API base URL')))
self.base_url_edit = QLineEdit()
self.base_url_edit.setText(QgsSettings().value('redistrict/base_url', '', str, QgsSettings.Plugins))
layout.addWidget(self.base_url_edit)
h_layout = QHBoxLayout()
h_layout.addWidget(QLabel(self.tr('Check for completed requests every')))
self.check_every_spin = QSpinBox()
self.check_every_spin.setMinimum(10)
self.check_every_spin.setMaximum(600)
self.check_every_spin.setSuffix(' ' + self.tr('s'))
self.check_every_spin.setValue(QgsSettings().value('redistrict/check_every', '30', int, QgsSettings.Plugins))
h_layout.addWidget(self.check_every_spin)
layout.addLayout(h_layout)
self.use_mock_checkbox = QCheckBox(self.tr('Use mock Statistics NZ API'))
self.use_mock_checkbox.setChecked(get_use_mock_api())
layout.addWidget(self.use_mock_checkbox)
self.test_button = QPushButton(self.tr('Test API connection'))
self.test_button.clicked.connect(self.test_api)
layout.addWidget(self.test_button)
self.use_overlays_checkbox = QCheckBox(self.tr('Show updated populations during interactive redistricting'))
self.use_overlays_checkbox.setChecked(
QgsSettings().value('redistrict/show_overlays', False, bool, QgsSettings.Plugins))
layout.addWidget(self.use_overlays_checkbox)
self.use_sound_group_box = QGroupBox(self.tr('Use audio feedback'))
self.use_sound_group_box.setCheckable(True)
self.use_sound_group_box.setChecked(
QgsSettings().value('redistrict/use_audio_feedback', False, bool, QgsSettings.Plugins))
sound_layout = QGridLayout()
sound_layout.addWidget(QLabel(self.tr('When meshblock redistricted')), 0, 0)
self.on_redistrict_file_widget = QgsFileWidget()
self.on_redistrict_file_widget.setDialogTitle(self.tr('Select Audio File'))
self.on_redistrict_file_widget.setStorageMode(QgsFileWidget.GetFile)
self.on_redistrict_file_widget.setFilePath(
QgsSettings().value('redistrict/on_redistrict', '', str, QgsSettings.Plugins))
self.on_redistrict_file_widget.setFilter(self.tr('Wave files (*.wav *.WAV)'))
sound_layout.addWidget(self.on_redistrict_file_widget, 0, 1)
self.play_on_redistrict_sound_button = QPushButton(self.tr('Test'))
self.play_on_redistrict_sound_button.clicked.connect(self.play_on_redistrict_sound)
sound_layout.addWidget(self.play_on_redistrict_sound_button, 0, 2)
self.use_sound_group_box.setLayout(sound_layout)
layout.addWidget(self.use_sound_group_box)
button_box = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
layout.addWidget(button_box)
button_box.rejected.connect(self.reject)
button_box.accepted.connect(self.accept)
self.setLayout(layout)
def accept(self): # pylint: disable=missing-docstring
super().accept()
QgsSettings().setValue('redistrict/auth_config_id', self.auth_value.configId(), QgsSettings.Plugins)
QgsSettings().setValue('redistrict/use_mock_api', self.use_mock_checkbox.isChecked(), QgsSettings.Plugins)
QgsSettings().setValue('redistrict/base_url', self.base_url_edit.text(), QgsSettings.Plugins)
QgsSettings().setValue('redistrict/check_every', self.check_every_spin.value(), QgsSettings.Plugins)
QgsSettings().setValue('redistrict/show_overlays', self.use_overlays_checkbox.isChecked(), QgsSettings.Plugins)
QgsSettings().setValue('redistrict/use_audio_feedback', self.use_sound_group_box.isChecked(),
QgsSettings.Plugins)
QgsSettings().setValue('redistrict/on_redistrict', self.on_redistrict_file_widget.filePath(),
QgsSettings.Plugins)
def test_api(self):
"""
Tests the API connection (real or mock!)
"""
connector = get_api_connector(use_mock=self.use_mock_checkbox.isChecked(),
authcfg=self.auth_value.configId(),
base_url=self.base_url_edit.text())
if connector.check():
QMessageBox.information(self, self.tr('Test API Connection'),
self.tr('API responded OK!'), QMessageBox.Ok)
else:
QMessageBox.critical(self, self.tr('Test API Connection'),
self.tr('Could not connect to API!'), QMessageBox.Ok)
def play_on_redistrict_sound(self):
"""
Plays the 'on redistrict' sound
"""
try:
playsound(self.on_redistrict_file_widget.filePath(), block=False)
except FileNotFoundError:
pass
class GeoServerWidget(ServerWidgetBase, BASE, WIDGET):
def __init__(self, parent, server_type):
super().__init__(parent, server_type)
self.setupUi(self)
self.geoserverAuth = QgsAuthConfigSelect()
self.geoserverAuth.selectedConfigIdChanged.connect(self.setDirty)
self.addAuthWidget()
self.populateStorageCombo()
self.comboStorageType.currentIndexChanged.connect(self.datastoreChanged)
self.btnRefreshDatabases.clicked.connect(partial(self.updateDbServersCombo, True))
self.btnAddDatastore.clicked.connect(self.addPostgisDatastore)
self.txtGeoserverName.textChanged.connect(self.setDirty)
self.txtGeoserverUrl.textChanged.connect(self.setDirty)
self.chkUseOriginalDataSource.stateChanged.connect(self.setDirty)
self.chkUseVectorTiles.stateChanged.connect(self.setDirty)
self.comboGeoserverDatabase.currentIndexChanged.connect(self.setDirty)
# Declare progress dialog
self._pgdialog = None
def createServerInstance(self):
""" Reads the settings form fields and returns a new server instance with these settings. """
db = None
storage = self.comboStorageType.currentIndex()
if storage in (GeoserverStorage.POSTGIS_BRIDGE, GeoserverStorage.POSTGIS_GEOSERVER):
db = self.comboGeoserverDatabase.currentText()
try:
name = self.txtGeoserverName.text().strip()
url = self.txtGeoserverUrl.text().strip()
if not name:
raise RuntimeError(f'missing {self.serverType.getLabel()} name')
if not url:
raise RuntimeError(f'missing {self.serverType.getLabel()} URL')
return self.serverType(
name=name,
authid=self.geoserverAuth.configId() or None,
url=url,
storage=storage,
postgisdb=db,
useOriginalDataSource=self.chkUseOriginalDataSource.isChecked(),
useVectorTiles=self.chkUseVectorTiles.isChecked()
)
except Exception as e:
self.parent.logError(f"Failed to create {self.serverType.getLabel()} instance: {e}")
return None
def newFromName(self, name: str):
""" Sets the name field and keeps all others empty. """
self.txtGeoserverName.setText(name)
self.txtGeoserverUrl.clear()
self.geoserverAuth.setConfigId(None)
# Set datastore and database comboboxes
self.comboStorageType.blockSignals(True)
self.comboStorageType.setCurrentIndex(GeoserverStorage.FILE_BASED)
self.datastoreChanged(GeoserverStorage.FILE_BASED)
self.chkUseOriginalDataSource.setChecked(False)
self.chkUseVectorTiles.setChecked(False)
self.comboStorageType.blockSignals(False)
def loadFromInstance(self, server):
""" Populates the form fields with the values from the given server instance. """
self.txtGeoserverName.setText(server.serverName)
self.txtGeoserverUrl.setText(server.baseUrl)
self.geoserverAuth.setConfigId(server.authId)
# Set datastore and database comboboxes
self.comboStorageType.blockSignals(True)
self.comboStorageType.setCurrentIndex(server.storage)
self.datastoreChanged(server.storage, server.postgisdb)
self.chkUseOriginalDataSource.setChecked(server.useOriginalDataSource)
self.chkUseVectorTiles.setChecked(server.useVectorTiles)
self.comboStorageType.blockSignals(False)
# After the data has loaded, the form is "clean"
self.setClean()
def addAuthWidget(self):
layout = QHBoxLayout()
layout.setContentsMargins(0, 3, 0, 0)
layout.addWidget(self.geoserverAuth)
self.geoserverAuthWidget.setLayout(layout)
self.geoserverAuthWidget.setFixedHeight(self.txtGeoserverUrl.height())
def populateStorageCombo(self):
self.comboStorageType.clear()
self.comboStorageType.addItems(GeoserverStorage.values())
def datastoreChanged(self, storage, init_value=None):
""" Called each time the database combobox selection changed. """
if storage is None:
storage = GeoserverStorage[self.comboStorageType.currentIndex()]
if storage == GeoserverStorage.POSTGIS_BRIDGE:
self.updateDbServersCombo(False, init_value)
self.comboGeoserverDatabase.setVisible(True)
self.labelGeoserverDatastore.setText('Database')
self.labelGeoserverDatastore.setVisible(True)
self.datastoreControls.setVisible(False)
elif storage == GeoserverStorage.POSTGIS_GEOSERVER:
self.comboGeoserverDatabase.setVisible(True)
self.labelGeoserverDatastore.setText('Datastore')
self.labelGeoserverDatastore.setVisible(True)
self.datastoreControls.setVisible(True)
self.updateDbServersCombo(True, init_value)
elif storage == GeoserverStorage.FILE_BASED:
self.comboGeoserverDatabase.setVisible(False)
self.labelGeoserverDatastore.setVisible(False)
self.datastoreControls.setVisible(False)
self.setDirty()
def addGeoserverPgDatastores(self, current, result):
if self._pgdialog and self._pgdialog.isVisible():
self._pgdialog.hide()
if result:
# Worker result might be a list of lists, so we should flatten it
datastores = list(chain.from_iterable(result))
self.comboGeoserverDatabase.addItems(datastores)
if current:
self.comboGeoserverDatabase.setCurrentText(current)
else:
self.parent.showWarningBar("Warning", "No PostGIS datastores on server or could not retrieve them")
def showProgressDialog(self, text, length, handler):
self._pgdialog = QProgressDialog(text, "Cancel", 0, length, self)
self._pgdialog.setWindowTitle(getAppName())
self._pgdialog.setWindowModality(QtCore.Qt.WindowModal)
self._pgdialog.canceled.connect(handler, type=QtCore.Qt.DirectConnection)
self._pgdialog.forceShow()
def updateDbServersCombo(self, managed_by_geoserver: bool, init_value=None):
""" (Re)populate the combobox with database-driven datastores.
:param managed_by_geoserver: If True, GeoServer manages the DB connection. If False, Bridge manages it.
:param init_value: When the combobox shows for the first time and no databases have been loaded,
this value can be set immediately as the only available and selected item.
Doing so prevents a full refresh of GeoServer datastores.
"""
if managed_by_geoserver and init_value:
if self.comboGeoserverDatabase.count() == 0:
# Only add the given init_value item to the empty combo (user should manually refresh)
self.comboGeoserverDatabase.addItem(init_value)
self.comboGeoserverDatabase.setCurrentText(init_value)
return
# If combo has values, try and find the init_value and set it to that (user should manually refresh)
index = self.comboGeoserverDatabase.findText(init_value)
if index >= 0:
self.comboGeoserverDatabase.setCurrentIndex(index)
return
current_db = self.comboGeoserverDatabase.currentText() or init_value
self.comboGeoserverDatabase.clear()
if managed_by_geoserver:
# Database is managed by GeoServer: instantiate server and retrieve datastores
# TODO: only PostGIS datastores are supported for now
server = self.createServerInstance()
if not server:
self.parent.showErrorBar("Error", "Bad values in server definition")
return
try:
# Retrieve workspaces (single REST request)
workspaces = gui.execute(server.getWorkspaces)
if not workspaces:
return
# Retrieve datastores for each workspace:
# This is a potentially long-running operation and uses a separate QThread
worker = gui.ItemProcessor(workspaces, server.getPostgisDatastores)
self.showProgressDialog("Fetching PostGIS datastores...", len(workspaces), worker.stop)
worker.progress.connect(self._pgdialog.setValue)
worker.finished.connect(partial(self.addGeoserverPgDatastores, current_db))
worker.run()
except Exception as e:
msg = f'Failed to retrieve datastores for {self.serverName}'
if isinstance(e, HTTPError) and e.response.status_code == 401:
msg = f'{msg}: please check credentials'
else:
msg = f'{msg}: {e}'
self.parent.showErrorBar(msg)
else:
# Database is managed by Bridge: iterate over all user-defined database connections
db_servers = self.parent.serverManager.getDbServerNames()
self.comboGeoserverDatabase.addItems(db_servers)
if current_db in db_servers:
self.comboGeoserverDatabase.setCurrentText(current_db)
def addPostgisDatastore(self):
server = self.createServerInstance()
if server is None:
self.parent.showErrorBar("Error", "Wrong values in server definition")
return
dlg = GeoserverDatastoreDialog(self)
dlg.exec_()
name = dlg.name
if name is None:
return
def _entry(k, v):
return {"@key": k, "$": v}
ds = {
"dataStore": {
"name": dlg.name,
"type": "PostGIS",
"enabled": True,
"connectionParameters": {
"entry": [
_entry("schema", dlg.schema),
_entry("port", dlg.port),
_entry("database", dlg.database),
_entry("passwd", dlg.password),
_entry("user", dlg.username),
_entry("host", dlg.host),
_entry("dbtype", "postgis")
]
}
}
}
try:
gui.execute(partial(server.addPostgisDatastore, ds))
except Exception as e:
self.parent.showErrorBar("Error", "Could not create new PostGIS dataset", propagate=e)
else:
self.updateDbServersCombo(True)
def __init__(self, parent=None): # pylint: disable=too-many-statements
super().__init__(parent)
self.setWindowTitle(self.tr('Redistrict Plugin | Settings'))
layout = QVBoxLayout()
self.auth_label = QLabel(self.tr('Authentication configuration'))
layout.addWidget(self.auth_label)
self.auth_value = QgsAuthConfigSelect()
layout.addWidget(self.auth_value)
auth_id = get_auth_config_id()
if auth_id:
self.auth_value.setConfigId(auth_id)
layout.addWidget(QLabel(self.tr('API base URL')))
self.base_url_edit = QLineEdit()
self.base_url_edit.setText(QgsSettings().value('redistrict/base_url', '', str, QgsSettings.Plugins))
layout.addWidget(self.base_url_edit)
h_layout = QHBoxLayout()
h_layout.addWidget(QLabel(self.tr('Check for completed requests every')))
self.check_every_spin = QSpinBox()
self.check_every_spin.setMinimum(10)
self.check_every_spin.setMaximum(600)
self.check_every_spin.setSuffix(' ' + self.tr('s'))
self.check_every_spin.setValue(QgsSettings().value('redistrict/check_every', '30', int, QgsSettings.Plugins))
h_layout.addWidget(self.check_every_spin)
layout.addLayout(h_layout)
self.use_mock_checkbox = QCheckBox(self.tr('Use mock Statistics NZ API'))
self.use_mock_checkbox.setChecked(get_use_mock_api())
layout.addWidget(self.use_mock_checkbox)
self.test_button = QPushButton(self.tr('Test API connection'))
self.test_button.clicked.connect(self.test_api)
layout.addWidget(self.test_button)
self.use_overlays_checkbox = QCheckBox(self.tr('Show updated populations during interactive redistricting'))
self.use_overlays_checkbox.setChecked(
QgsSettings().value('redistrict/show_overlays', False, bool, QgsSettings.Plugins))
layout.addWidget(self.use_overlays_checkbox)
self.use_sound_group_box = QGroupBox(self.tr('Use audio feedback'))
self.use_sound_group_box.setCheckable(True)
self.use_sound_group_box.setChecked(
QgsSettings().value('redistrict/use_audio_feedback', False, bool, QgsSettings.Plugins))
sound_layout = QGridLayout()
sound_layout.addWidget(QLabel(self.tr('When meshblock redistricted')), 0, 0)
self.on_redistrict_file_widget = QgsFileWidget()
self.on_redistrict_file_widget.setDialogTitle(self.tr('Select Audio File'))
self.on_redistrict_file_widget.setStorageMode(QgsFileWidget.GetFile)
self.on_redistrict_file_widget.setFilePath(
QgsSettings().value('redistrict/on_redistrict', '', str, QgsSettings.Plugins))
self.on_redistrict_file_widget.setFilter(self.tr('Wave files (*.wav *.WAV)'))
sound_layout.addWidget(self.on_redistrict_file_widget, 0, 1)
self.play_on_redistrict_sound_button = QPushButton(self.tr('Test'))
self.play_on_redistrict_sound_button.clicked.connect(self.play_on_redistrict_sound)
sound_layout.addWidget(self.play_on_redistrict_sound_button, 0, 2)
self.use_sound_group_box.setLayout(sound_layout)
layout.addWidget(self.use_sound_group_box)
button_box = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
layout.addWidget(button_box)
button_box.rejected.connect(self.reject)
button_box.accepted.connect(self.accept)
self.setLayout(layout)
# coding: utf-8 from qgis.gui import QgsAuthConfigSelect auth_config_select = QgsAuthConfigSelect() auth_config_select.show()
class ServerConnectionsWidget(BASE, WIDGET):
def __init__(self):
super(ServerConnectionsWidget, self).__init__()
self.currentServer = None
self.setupUi(self)
self.addMenuToButtonNew()
self.addAuthWidgets()
self.buttonRemove.clicked.connect(self.buttonRemoveClicked)
self.populateServers()
self.listServers.currentItemChanged.connect(self.currentServerChanged)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().insertWidget(0, self.bar)
self.setCurrentServer(None)
self.buttonSave.clicked.connect(self.saveButtonClicked)
self.comboGeoserverDataStorage.currentIndexChanged.connect(
self.geoserverDatastorageChanged)
self.btnConnectGeoserver.clicked.connect(self.testConnectionGeoserver)
self.btnConnectPostgis.clicked.connect(self.testConnectionPostgis)
self.btnConnectGeocatLive.clicked.connect(
self.testConnectionGeocatLive)
self.btnConnectCsw.clicked.connect(self.testConnectionCsw)
self.btnAddDatastore.clicked.connect(self.addPostgisDatastore)
self.btnRefreshDatabases.clicked.connect(
self.populatePostgisComboWithGeoserverPostgisServers)
self.txtCswName.textChanged.connect(self._setCurrentServerHasChanges)
self.txtCswNode.textChanged.connect(self._setCurrentServerHasChanges)
self.txtGeoserverName.textChanged.connect(
self._setCurrentServerHasChanges)
self.txtPostgisName.textChanged.connect(
self._setCurrentServerHasChanges)
self.txtGeoserverUrl.textChanged.connect(
self._setCurrentServerHasChanges)
self.txtGeocatLiveName.textChanged.connect(
self._setCurrentServerHasChanges)
self.txtCswUrl.textChanged.connect(self._setCurrentServerHasChanges)
self.txtPostgisServerAddress.textChanged.connect(
self._setCurrentServerHasChanges)
self.txtPostgisPort.textChanged.connect(
self._setCurrentServerHasChanges)
self.txtPostgisSchema.textChanged.connect(
self._setCurrentServerHasChanges)
self.txtPostgisDatabase.textChanged.connect(
self._setCurrentServerHasChanges)
self.txtGeocatLiveIdentifier.textChanged.connect(
self._setCurrentServerHasChanges)
self.comboMetadataProfile.currentIndexChanged.connect(
self._setCurrentServerHasChanges)
self.comboGeoserverDatabase.currentIndexChanged.connect(
self._setCurrentServerHasChanges)
self.radioLocalPath.toggled.connect(self.mapserverStorageChanged)
self.fileMapserver.setStorageMode(QgsFileWidget.GetDirectory)
self.btnSaveServers.clicked.connect(self.saveServers)
self.btnLoadServers.clicked.connect(self.loadServers)
self.comboMetadataProfile.setVisible(False)
self.labelMetadataProfile.setVisible(False)
def checkServersHaveBeenDefined(self):
if self.listServers.count():
self.txtNoServers.setVisible(False)
self.listServers.setVisible(True)
else:
self.txtNoServers.setVisible(True)
self.listServers.setVisible(False)
def saveServers(self):
filename = QFileDialog.getSaveFileName(self, self.tr("Save servers"),
"", '*.json')[0]
if filename:
if not filename.endswith("json"):
filename += ".json"
with open(filename, "w") as f:
f.write(serversAsJsonString())
def loadServers(self):
filename = QFileDialog.getOpenFileName(self, self.tr("Load servers"),
"", '*.json')[0]
if filename:
with open(filename) as f:
servers = json.load(f)
for server in servers:
s = serverFromDefinition(server)
if s.name not in allServers():
self.addServerItem(s)
addServer(s)
def geoserverDatastorageChanged(self):
storage = self.comboGeoserverDataStorage.currentIndex()
if storage == GeoserverServer.POSTGIS_MANAGED_BY_BRIDGE:
self.populatePostgisComboWithPostgisServers()
self.comboGeoserverDatabase.setVisible(True)
self.btnAddDatastore.setVisible(False)
self.labelGeoserverDatastore.setVisible(True)
self.btnRefreshDatabases.setVisible(False)
elif storage == GeoserverServer.POSTGIS_MANAGED_BY_GEOSERVER:
self.comboGeoserverDatabase.setVisible(True)
self.btnAddDatastore.setVisible(True)
self.labelGeoserverDatastore.setVisible(True)
self.btnRefreshDatabases.setVisible(True)
self.populatePostgisComboWithGeoserverPostgisServers()
else:
self.comboGeoserverDatabase.setVisible(False)
self.btnAddDatastore.setVisible(False)
self.labelGeoserverDatastore.setVisible(False)
self.btnRefreshDatabases.setVisible(False)
self._setCurrentServerHasChanges()
def addPostgisDatastore(self):
url = self.txtGeoserverUrl.text().strip()
server = self.createGeoserverServer()
if server is None:
self.bar.pushMessage(self.tr("Wrong values in server definition"),
level=Qgis.Warning,
duration=5)
return
dlg = NewDatasetDialog(self)
dlg.exec_()
name = dlg.name
if name is None:
return
def _entry(k, v):
return {"@key": k, "$": v}
ds = {
"dataStore": {
"name": dlg.name,
"type": "PostGIS",
"enabled": True,
"connectionParameters": {
"entry": [
_entry("schema", dlg.schema),
_entry("port", dlg.port),
_entry("database", dlg.database),
_entry("passwd", dlg.password),
_entry("user", dlg.username),
_entry("host", dlg.host),
_entry("dbtype", "postgis")
]
}
}
}
try:
datastores = execute(lambda: server.addPostgisDatastore(ds))
self.populatePostgisComboWithGeoserverPostgisServers()
except:
self.bar.pushMessage(
self.tr("Could not create new PostGIS dataset"),
level=Qgis.Warning,
duration=5)
def mapserverStorageChanged(self, checked):
self.labelLocalFolder.setVisible(checked)
self.labelRemoteFolder.setVisible(not checked)
self.fileMapserver.setVisible(checked)
self.txtRemoteFolder.setVisible(not checked)
self.labelHost.setVisible(not checked)
self.labelPort.setVisible(not checked)
self.labelMapserverCredentials.setVisible(not checked)
self.txtMapserverHost.setVisible(not checked)
self.txtMapserverPort.setVisible(not checked)
self.mapserverAuthWidget.setVisible(not checked)
self._setCurrentServerHasChanges()
def currentServerChanged(self, new, old):
if new is None:
self.setCurrentServer(new)
return
else:
name = self.listServers.itemWidget(new).serverName()
server = allServers()[name]
if self.currentServer is not None and new is not None:
if server.name == self.currentServer.name:
return
if self.currentServerHasChanges:
res = QMessageBox.question(
self, self.tr("Servers"),
self.tr(
"Do you want to save changes to the current server?"),
QMessageBox.Cancel | QMessageBox.No | QMessageBox.Yes,
QMessageBox.Yes)
if res == QMessageBox.Yes:
if not self.saveCurrentServer():
self.bar.pushMessage(
self.tr("Error"),
self.tr("Wrong values in current item"),
level=Qgis.Warning,
duration=5)
self.listServers.setCurrentItem(old)
else:
self.setCurrentServer(server)
elif res == QMessageBox.Cancel:
self.listServers.setCurrentItem(old)
else:
self.setCurrentServer(server)
else:
self.setCurrentServer(server)
def _testConnection(self, server):
if server is None:
self.bar.pushMessage(self.tr("Error"),
self.tr("Wrong values in current item"),
level=Qgis.Warning,
duration=5)
else:
if execute(server.testConnection):
self.bar.pushMessage(
self.tr("Success"),
self.tr("Connection succesfully established with server"),
level=Qgis.Success,
duration=5)
else:
self.bar.pushMessage(self.tr("Error"),
self.tr("Could not connect with server"),
level=Qgis.Warning,
duration=5)
def testConnectionPostgis(self):
server = self.createPostgisServer()
self._testConnection(server)
def testConnectionGeoserver(self):
server = self.createGeoserverServer()
self._testConnection(server)
def testConnectionGeocatLive(self):
server = self.createGeocatLiveServer()
self._testConnection(server)
def testConnectionCsw(self):
server = self.createGeonetworkServer()
self._testConnection(server)
def saveCurrentServer(self):
w = self.stackedWidget.currentWidget()
server = None
if w == self.widgetEmpty:
return True
elif w == self.widgetGeoserver:
server = self.createGeoserverServer()
elif w == self.widgetMapserver:
server = self.createMapserverServer()
elif w == self.widgetPostgis:
server = self.createPostgisServer()
elif w == self.widgetMetadataCatalog:
server = self.createGeonetworkServer()
elif w == self.widgetGeocatLive:
server = self.createGeocatLiveServer()
if server is None:
return False
else:
if self.currentServer is not None:
removeServer(self.currentServer.name)
item = self.itemFromServerName(self.currentServer.name)
self.listServers.itemWidget(item).setServerName(server.name)
addServer(server)
self.currentServer = server
return True
def itemFromServerName(self, name):
for i in range(self.listServers.count()):
item = self.listServers.item(i)
if name == self.listServers.itemWidget(item).serverName():
return item
def createGeoserverServer(self):
##TODO check validity of name and values
name = self.txtGeoserverName.text().strip()
url = self.txtGeoserverUrl.text().strip()
authid = self.geoserverAuth.configId()
if not bool(authid):
return None
storage = self.comboGeoserverDataStorage.currentIndex()
postgisdb = None
if storage in [
GeoserverServer.POSTGIS_MANAGED_BY_BRIDGE,
GeoserverServer.POSTGIS_MANAGED_BY_GEOSERVER
]:
postgisdb = self.comboGeoserverDatabase.currentText()
useOriginalDataSource = self.chkUseOriginalDataSource.isChecked()
if "" in [name, url]:
return None
server = GeoserverServer(name, url, authid, storage, postgisdb,
useOriginalDataSource)
return server
def createPostgisServer(self):
##TODO check validity of name and values
name = self.txtPostgisName.text()
host = self.txtPostgisServerAddress.text()
port = self.txtPostgisPort.text()
schema = self.txtPostgisSchema.text()
database = self.txtPostgisDatabase.text()
authid = self.postgisAuth.configId()
server = PostgisServer(name, authid, host, port, schema, database)
return server
def createGeonetworkServer(self):
##TODO check validity of name and values
name = self.txtCswName.text()
node = self.txtCswNode.text()
authid = self.cswAuth.configId()
if bool(authid):
url = self.txtCswUrl.text()
profile = self.comboMetadataProfile.currentIndex()
server = GeonetworkServer(name, url, authid, profile, node)
return server
def createMapserverServer(self):
##TODO check validity of name and values
name = self.txtMapserverName.text()
authid = self.mapserverAuth.configId()
host = self.txtMapserverHost.text()
try:
port = int(self.txtMapserverPort.text())
except:
return None
local = self.radioLocalPath.isChecked()
if local:
folder = self.fileMapserver.filePath()
else:
folder = self.txtRemoteFolder.text()
url = self.txtMapserverUrl.text()
servicesPath = self.txtMapServicesPath.text()
projFolder = self.txtProjFolder.text()
server = MapserverServer(name, url, local, folder, authid, host, port,
servicesPath, projFolder)
return server
def createGeocatLiveServer(self):
name = self.txtGeocatLiveName.text()
geoserverAuthid = self.geocatLiveGeoserverAuth.configId()
geonetworkAuthid = self.geocatLiveGeonetworkAuth.configId()
if bool(geoserverAuthid) and bool(geonetworkAuthid):
userid = self.txtGeocatLiveIdentifier.text()
server = GeocatLiveServer(name, userid, geoserverAuthid,
geonetworkAuthid)
return server
def addAuthWidgets(self):
self.geoserverAuth = QgsAuthConfigSelect()
self.geoserverAuth.selectedConfigIdChanged.connect(
self._setCurrentServerHasChanges)
layout = QHBoxLayout()
layout.setMargin(0)
layout.addWidget(self.geoserverAuth)
self.geoserverAuthWidget.setLayout(layout)
self.geoserverAuthWidget.setFixedHeight(self.txtGeoserverUrl.height())
self.mapserverAuth = QgsAuthConfigSelect()
self.mapserverAuth.selectedConfigIdChanged.connect(
self._setCurrentServerHasChanges)
layout = QHBoxLayout()
layout.setMargin(0)
layout.addWidget(self.mapserverAuth)
self.mapserverAuthWidget.setLayout(layout)
self.mapserverAuthWidget.setFixedHeight(self.txtGeoserverUrl.height())
self.postgisAuth = QgsAuthConfigSelect()
self.postgisAuth.selectedConfigIdChanged.connect(
self._setCurrentServerHasChanges)
layout = QHBoxLayout()
layout.setMargin(0)
layout.addWidget(self.postgisAuth)
self.postgisAuthWidget.setLayout(layout)
self.postgisAuthWidget.setFixedHeight(self.txtGeoserverUrl.height())
self.cswAuth = QgsAuthConfigSelect()
self.cswAuth.selectedConfigIdChanged.connect(
self._setCurrentServerHasChanges)
layout = QHBoxLayout()
layout.setMargin(0)
layout.addWidget(self.cswAuth)
self.cswAuthWidget.setLayout(layout)
self.cswAuthWidget.setFixedHeight(self.txtGeoserverUrl.height())
self.geocatLiveGeoserverAuth = QgsAuthConfigSelect()
self.geocatLiveGeoserverAuth.selectedConfigIdChanged.connect(
self._setCurrentServerHasChanges)
layout = QHBoxLayout()
layout.setMargin(0)
layout.addWidget(self.geocatLiveGeoserverAuth)
self.geocatLiveGeoserverAuthWidget.setLayout(layout)
self.geocatLiveGeoserverAuthWidget.setFixedHeight(
self.txtGeoserverUrl.height())
self.geocatLiveGeonetworkAuth = QgsAuthConfigSelect()
self.geocatLiveGeonetworkAuth.selectedConfigIdChanged.connect(
self._setCurrentServerHasChanges)
layout = QHBoxLayout()
layout.setMargin(0)
layout.addWidget(self.geocatLiveGeonetworkAuth)
self.geocatLiveGeonetworkAuthWidget.setLayout(layout)
self.geocatLiveGeonetworkAuthWidget.setFixedHeight(
self.txtGeoserverUrl.height())
def addMenuToButtonNew(self):
menu = QMenu()
menu.addAction("GeoServer",
lambda: self._addServer("GeoServer", GeoserverServer))
menu.addAction("MapServer",
lambda: self._addServer("MapServer", MapserverServer))
menu.addAction(
"GeoCat Live",
lambda: self._addServer("GeoCat Live", GeocatLiveServer))
menu.addAction("GeoNetwork",
lambda: self._addServer("GeoNetwork", GeonetworkServer))
#menu.addAction("CSW", lambda: self._addServer("CSW", CswServer))
menu.addAction("PostGIS",
lambda: self._addServer("PostGIS", PostgisServer))
self.buttonNew.setMenu(menu)
def buttonRemoveClicked(self):
item = self.listServers.currentItem()
if item is None:
return
name = self.listServers.itemWidget(item).serverName()
removeServer(name)
self.listServers.takeItem(self.listServers.currentRow())
self.listServers.setCurrentItem(None)
self.checkServersHaveBeenDefined()
def populateServers(self):
self.listServers.clear()
servers = allServers().values()
for server in servers:
self.addServerItem(server)
self.checkServersHaveBeenDefined()
def addServerItem(self, server):
widget = ServerItemWidget(server)
item = QListWidgetItem(self.listServers)
item.setSizeHint(widget.sizeHint())
self.listServers.addItem(item)
self.listServers.setItemWidget(item, widget)
self.checkServersHaveBeenDefined()
return item
def _addServer(self, name, clazz):
if self.currentServerHasChanges:
self.bar.pushMessage(
self.tr("Save changes to current server before creating one"),
level=Qgis.Warning,
duration=5)
else:
name = self.getNewName(name)
server = clazz(name)
addServer(server)
self.setCurrentServer(server)
item = self.addServerItem(server)
self.listServers.setCurrentItem(item)
def populatePostgisComboWithPostgisServers(self):
self.comboGeoserverDatabase.clear()
servers = allServers().values()
for s in servers:
if isinstance(s, PostgisServer):
self.comboGeoserverDatabase.addItem(s.name)
def populatePostgisComboWithGeoserverPostgisServers(self):
url = self.txtGeoserverUrl.text().strip()
self.comboGeoserverDatabase.clear()
server = self.createGeoserverServer()
if server is None:
self.bar.pushMessage(self.tr("Wrong values in server definition"),
level=Qgis.Warning,
duration=5)
return
try:
datastores = execute(server.postgisDatastores)
except:
datastores = []
if datastores:
self.comboGeoserverDatabase.addItems(datastores)
else:
self.bar.pushMessage(self.tr(
"No PostGIS datastores in server or could not retrieve them"),
level=Qgis.Warning,
duration=5)
def _setCurrentServerHasChanges(self):
self.currentServerHasChanges = True
def setCurrentServer(self, server):
self.currentServer = server
if server is None:
self.stackedWidget.setCurrentWidget(self.widgetEmpty)
elif isinstance(server, GeoserverServer):
self.stackedWidget.setCurrentWidget(self.widgetGeoserver)
self.txtGeoserverName.setText(server.name)
self.txtGeoserverUrl.setText(server.url)
self.geoserverAuth.setConfigId(server.authid)
self.comboGeoserverDataStorage.blockSignals(True)
self.comboGeoserverDataStorage.setCurrentIndex(server.storage)
self.geoserverDatastorageChanged()
if server.postgisdb is not None:
self.comboGeoserverDatabase.setCurrentText(server.postgisdb)
self.chkUseOriginalDataSource.setChecked(
server.useOriginalDataSource)
self.comboGeoserverDataStorage.blockSignals(False)
elif isinstance(server, MapserverServer):
self.stackedWidget.setCurrentWidget(self.widgetMapserver)
self.txtMapserverName.setText(server.name)
self.fileMapserver.setFilePath(server.folder)
self.txtRemoteFolder.setText(server.folder)
self.txtMapserverHost.setText(server.host)
self.txtMapserverPort.setText(str(server.port))
self.mapserverAuth.setConfigId(server.authid)
self.txtMapserverUrl.setText(server.url)
self.txtMapServicesPath.setText(server.servicesPath)
self.txtProjFolder.setText(server.projFolder)
self.radioLocalPath.setChecked(server.useLocalFolder)
self.radioFtp.setChecked(not server.useLocalFolder)
self.mapserverStorageChanged(server.useLocalFolder)
elif isinstance(server, PostgisServer):
self.stackedWidget.setCurrentWidget(self.widgetPostgis)
self.txtPostgisName.setText(server.name)
self.txtPostgisDatabase.setText(server.database)
self.txtPostgisPort.setText(server.port)
self.txtPostgisServerAddress.setText(server.host)
self.txtPostgisSchema.setText(server.schema)
self.postgisAuth.setConfigId(server.authid)
elif isinstance(server, (GeonetworkServer, CswServer)):
self.stackedWidget.setCurrentWidget(self.widgetMetadataCatalog)
self.txtCswName.setText(server.name)
self.txtCswNode.setText(server.node)
self.txtCswUrl.setText(server.url)
self.cswAuth.setConfigId(server.authid)
self.comboMetadataProfile.setCurrentIndex(server.profile)
elif isinstance(server, GeocatLiveServer):
self.stackedWidget.setCurrentWidget(self.widgetGeocatLive)
self.txtGeocatLiveName.setText(server.name)
self.txtGeocatLiveIdentifier.setText(server.userid)
self.geocatLiveGeoserverAuth.setConfigId(server.geoserverAuthid)
self.geocatLiveGeonetworkAuth.setConfigId(server.geonetworkAuthid)
self.currentServerHasChanges = False
def getNewName(self, name):
servers = list(allServers().keys())
i = 1
while True:
n = name + str(i)
if n not in servers:
return n
else:
i += 1
def saveButtonClicked(self):
if self.saveCurrentServer():
self.currentServerHasChanges = False
else:
self.bar.pushMessage(self.tr("Error"),
self.tr("Wrong values in current item"),
level=Qgis.Warning,
duration=5)
def canClose(self):
if self.currentServerHasChanges:
res = QMessageBox.question(
self, self.tr("Servers"),
self.
tr("Do you want to close without saving the current changes?"),
QMessageBox.Cancel | QMessageBox.No | QMessageBox.Yes,
QMessageBox.Yes)
return res == QMessageBox.Yes
else:
return True
class PostgisWidget(ServerWidgetBase, BASE, WIDGET):
def __init__(self, parent, server_type):
super().__init__(parent, server_type)
self.setupUi(self)
self.postgisAuth = QgsAuthConfigSelect()
self.postgisAuth.selectedConfigIdChanged.connect(self.setDirty)
self.addAuthWidget()
self.txtPostgisName.textChanged.connect(self.setDirty)
self.txtPostgisServerAddress.textChanged.connect(self.setDirty)
self.txtPostgisPort.textChanged.connect(self.setDirty)
self.txtPostgisSchema.textChanged.connect(self.setDirty)
self.txtPostgisDatabase.textChanged.connect(self.setDirty)
def createServerInstance(self):
""" Reads the settings form fields and returns a new server instance with these settings. """
try:
name = self.txtPostgisName.text().strip()
host = self.txtPostgisServerAddress.text().strip()
if not name:
raise RuntimeError(
f'missing {self.serverType.getLabel()} name')
if not host:
raise RuntimeError(
f'missing {self.serverType.getLabel()} host address')
try:
port = int(self.txtPostgisPort.text())
except (ValueError, TypeError):
raise RuntimeError(
f'missing or invalid {self.serverType.getLabel()} port')
return self.serverType(
name=name,
authid=self.postgisAuth.configId(),
host=host,
port=port,
schema=self.txtPostgisSchema.text().strip(),
database=self.txtPostgisDatabase.text().strip())
except Exception as e:
self.parent.logError(
f"Failed to create {self.serverType.getLabel()} instance: {e}")
return None
def newFromName(self, name: str):
""" Sets the name field and keeps all others empty. """
self.txtPostgisName.setText(name)
self.txtPostgisDatabase.clear()
self.txtPostgisPort.clear()
self.txtPostgisServerAddress.clear()
self.txtPostgisSchema.clear()
self.postgisAuth.setConfigId(None)
def loadFromInstance(self, server):
""" Populates the form fields with the values from the given server instance. """
self.txtPostgisName.setText(server.serverName)
self.txtPostgisDatabase.setText(server.database)
self.txtPostgisPort.setText(server.port)
self.txtPostgisServerAddress.setText(server.host)
self.txtPostgisSchema.setText(server.schema)
self.postgisAuth.setConfigId(server.authid)
# After the data has loaded, the form is "clean"
self.setClean()
def addAuthWidget(self):
layout = QHBoxLayout()
layout.setContentsMargins(0, 3, 0, 0)
layout.addWidget(self.postgisAuth)
self.postgisAuthWidget.setLayout(layout)
self.postgisAuthWidget.setFixedHeight(
self.txtPostgisServerAddress.height())
class ALKISConf(QDialog, ConfBase):
def __init__(self, plugin):
QDialog.__init__(self)
self.setupUi(self)
self.plugin = plugin
self.settings = plugin.settings
self.settings.loadSettings()
self.leSERVICE.setText(self.settings.service)
self.leHOST.setText(self.settings.host)
self.lePORT.setText(self.settings.port)
self.leDBNAME.setText(self.settings.dbname)
self.leSCHEMA.setText(self.settings.schema)
self.leUID.setText(self.settings.uid)
self.lePWD.setText(self.settings.pwd)
self.cbxSignaturkatalog.setEnabled(False)
if hasattr(qgis.gui, 'QgsAuthConfigSelect'):
self.authCfgSelect = QgsAuthConfigSelect(self, "postgres")
self.tabWidget.insertTab(1, self.authCfgSelect, "Konfigurationen")
authcfg = self.settings.authcfg
if authcfg:
self.tabWidget.setCurrentIndex(1)
self.authCfgSelect.setConfigId(authcfg)
self.leUMNPath.setText(self.settings.umnpath)
self.pbUMNBrowse.clicked.connect(self.browseUMNPath)
self.leUMNTemplate.setText(self.settings.umntemplate)
self.teFussnote.setPlainText(self.settings.footnote)
self.loadModels(False)
self.bb.accepted.connect(self.accept)
self.bb.rejected.connect(self.reject)
self.bb.addButton("Modelle laden", QDialogButtonBox.ActionRole).clicked.connect(self.loadModels)
self.bb.addButton("Layer einbinden", QDialogButtonBox.ActionRole).clicked.connect(self.loadLayers)
self.restoreGeometry(QSettings("norBIT", "norGIS-ALKIS-Erweiterung").value("confgeom", QByteArray(), type=QByteArray))
def done(self, r):
QSettings("norBIT", "norGIS-ALKIS-Erweiterung").setValue("confgeom", self.saveGeometry())
return QDialog.done(self, r)
def loadModels(self, error=True):
self.settings.service = self.leSERVICE.text()
self.settings.host = self.leHOST.text()
self.settings.port = self.lePORT.text()
self.settings.dbname = self.leDBNAME.text()
self.settings.schema = self.leSCHEMA.text()
self.settings.uid = self.leUID.text()
self.settings.pwd = self.lePWD.text()
if hasattr(qgis.gui, 'QgsAuthConfigSelect'):
self.settings.authcfg = self.authCfgSelect.configId()
self.twModellarten.clearContents()
self.cbxSignaturkatalog.clear()
(db, conninfo) = self.plugin.opendb()
if not db:
if error:
QMessageBox.critical(None, "ALKIS", u"Datenbankverbindung schlug fehl.")
self.settings.load()
return
modelle = self.settings.modellarten
if modelle is None:
modelle = ['DLKM', 'DKKM1000']
qry = QSqlQuery(db)
if qry.exec_("""
SELECT modell,count(*)
FROM (
SELECT unnest(modell) AS modell FROM po_points UNION ALL
SELECT unnest(modell) AS modell FROM po_lines UNION ALL
SELECT unnest(modell) AS modell FROM po_polygons UNION ALL
SELECT unnest(modell) AS modell from po_lines UNION ALL
SELECT unnest(modell) AS modell from po_labels
) AS foo
GROUP BY modell
ORDER BY count(*) DESC
"""):
res = {}
while qry.next():
res[qry.value(0)] = qry.value(1)
self.twModellarten.setRowCount(len(res))
i = 0
for k, n in sorted(iter(list(res.items())), key=operator.itemgetter(1), reverse=True):
item = QTableWidgetItem(k)
item.setCheckState(Qt.Checked if (item.text() in modelle) else Qt.Unchecked)
self.twModellarten.setItem(i, 0, item)
item = QTableWidgetItem(str(n))
self.twModellarten.setItem(i, 1, item)
i += 1
self.twModellarten.resizeColumnsToContents()
self.twModellarten.setEnabled(True)
else:
self.twModellarten.clearContents()
self.twModellarten.setDisabled(True)
if qry.exec_("SELECT id,name FROM alkis_signaturkataloge"):
while qry.next():
self.cbxSignaturkatalog.addItem(qry.value(1), int(qry.value(0)))
self.cbxSignaturkatalog.setEnabled(True)
else:
self.cbxSignaturkatalog.addItem(u"Farbe", -1)
self.cbxSignaturkatalog.setCurrentIndex(max([0, self.cbxSignaturkatalog.findData(self.settings.signaturkatalog)]))
self.settings.load()
def saveSettings(self):
self.settings.service = self.leSERVICE.text()
self.settings.host = self.leHOST.text()
self.settings.port = self.lePORT.text()
self.settings.dbname = self.leDBNAME.text()
self.settings.schema = self.leSCHEMA.text()
self.settings.uid = self.leUID.text()
self.settings.pwd = self.lePWD.text()
if hasattr(qgis.gui, 'QgsAuthConfigSelect'):
self.settings.authcfg = self.authCfgSelect.configId()
self.settings.umnpath = self.leUMNPath.text()
self.settings.umntemplate = self.leUMNTemplate.text()
self.settings.footnote = self.teFussnote.toPlainText()
modelle = []
if self.twModellarten.isEnabled():
for i in range(self.twModellarten.rowCount()):
item = self.twModellarten.item(i, 0)
if item.checkState() == Qt.Checked:
modelle.append(item.text())
self.settings.modellarten = modelle
self.settings.signaturkatalog = self.cbxSignaturkatalog.itemData(self.cbxSignaturkatalog.currentIndex())
self.settings.saveSettings()
def loadLayers(self):
self.saveSettings()
self.plugin.run()
self.settings.load()
QDialog.accept(self)
def accept(self):
self.saveSettings()
self.settings.load()
QDialog.accept(self)
def browseUMNPath(self):
path = self.leUMNPath.text()
path = QFileDialog.getExistingDirectory(self, u"UMN-Pfad wählen", path)
if path != "":
self.leUMNPath.setText(path)
class ServerConnectionsWidget(BASE, WIDGET):
def __init__(self):
super(ServerConnectionsWidget, self).__init__()
self.currentServer = None
self.setupUi(self)
self.addMenuToButtonNew()
self.addAuthWidgets()
self.buttonRemove.clicked.connect(self.buttonRemoveClicked)
self.populateServers()
self.populatePostgisCombo()
self.listServers.currentItemChanged.connect(self.currentServerChanged)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().insertWidget(0, self.bar)
self.setCurrentServer(None)
self.buttonSave.clicked.connect(self.saveButtonClicked)
self.radioUploadData.toggled.connect(self.datastoreChanged)
self.radioLocalPath.toggled.connect(self.mapserverStorageChanged)
self.btnConnectGeoserver.clicked.connect(self.testConnectionGeoserver)
self.btnConnectPostgis.clicked.connect(self.testConnectionPostgis)
self.btnConnectGeocatLive.clicked.connect(
self.testConnectionGeocatLive)
self.btnConnectCsw.clicked.connect(self.testConnectionCsw)
self.chkManagedWorkspace.stateChanged.connect(
self.managedWorkspaceChanged)
self.txtCswName.textChanged.connect(self._setCurrentServerHasChanges)
self.txtCswNode.textChanged.connect(self._setCurrentServerHasChanges)
self.txtGeoserverName.textChanged.connect(
self._setCurrentServerHasChanges)
self.txtPostgisName.textChanged.connect(
self._setCurrentServerHasChanges)
self.txtGeoserverUrl.textChanged.connect(
self._setCurrentServerHasChanges)
self.txtGeocatLiveName.textChanged.connect(
self._setCurrentServerHasChanges)
self.txtCswUrl.textChanged.connect(self._setCurrentServerHasChanges)
self.txtPostgisServerAddress.textChanged.connect(
self._setCurrentServerHasChanges)
self.txtPostgisPort.textChanged.connect(
self._setCurrentServerHasChanges)
self.txtPostgisSchema.textChanged.connect(
self._setCurrentServerHasChanges)
self.txtPostgisDatabase.textChanged.connect(
self._setCurrentServerHasChanges)
self.txtGeoserverWorkspace.textChanged.connect(
self._setCurrentServerHasChanges)
self.txtGeocatLiveIdentifier.textChanged.connect(
self._setCurrentServerHasChanges)
self.comboMetadataProfile.currentIndexChanged.connect(
self._setCurrentServerHasChanges)
self.comboDatastore.currentIndexChanged.connect(
self._setCurrentServerHasChanges)
self.fileMapserver.setStorageMode(QgsFileWidget.GetDirectory)
def datastoreChanged(self, checked):
self.comboDatastore.setEnabled(not checked)
#self.btnNewDatastore.setEnabled(not checked)
self._setCurrentServerHasChanges()
def managedWorkspaceChanged(self, state):
self.txtGeoserverWorkspace.setEnabled(state == Qt.Unchecked)
def mapserverStorageChanged(self, checked):
self.labelLocalFolder.setVisible(checked)
self.labelRemoteFolder.setVisible(not checked)
self.fileMapserver.setVisible(checked)
self.txtRemoteFolder.setVisible(not checked)
self.labelHost.setVisible(not checked)
self.labelPort.setVisible(not checked)
self.labelMapserverCredentials.setVisible(not checked)
self.txtMapserverHost.setVisible(not checked)
self.txtMapserverPort.setVisible(not checked)
self.mapserverAuthWidget.setVisible(not checked)
self._setCurrentServerHasChanges()
def currentServerChanged(self, new, old):
if new is None:
self.setCurrentServer(new)
return
else:
name = self.listServers.itemWidget(new).serverName()
server = allServers()[name]
if self.currentServer is not None and new is not None:
if server.name == self.currentServer.name:
return
if self.currentServerHasChanges:
res = QMessageBox.question(
self, self.tr("Servers"),
self.tr(
"Do you want to save changes to the current server?"),
QMessageBox.Cancel | QMessageBox.No | QMessageBox.Yes,
QMessageBox.Yes)
if res == QMessageBox.Yes:
if not self.saveCurrentServer():
self.bar.pushMessage(
self.tr("Error"),
self.tr("Wrong values in current item"),
level=Qgis.Warning,
duration=5)
self.listServers.setCurrentItem(old)
else:
self.setCurrentServer(server)
elif res == QMessageBox.Cancel:
self.listServers.setCurrentItem(old)
else:
self.setCurrentServer(server)
else:
self.setCurrentServer(server)
def _testConnection(self, server):
if server is None:
self.bar.pushMessage(self.tr("Error"),
self.tr("Wrong values in current item"),
level=Qgis.Warning,
duration=5)
else:
if execute(server.testConnection):
self.bar.pushMessage(
self.tr("Success"),
self.tr("Connection succesfully established with server"),
level=Qgis.Success,
duration=5)
else:
self.bar.pushMessage(self.tr("Error"),
self.tr("Could not connect with server"),
level=Qgis.Warning,
duration=5)
def testConnectionPostgis(self):
server = self.createPostgisServer()
self._testConnection(server)
def testConnectionGeoserver(self):
server = self.createGeoserverServer()
self._testConnection(server)
def testConnectionGeocatLive(self):
server = self.createGeocatLiveServer()
self._testConnection(server)
def testConnectionCsw(self):
server = self.createGeonetworkServer()
self._testConnection(server)
def saveCurrentServer(self):
w = self.stackedWidget.currentWidget()
server = None
if w == self.widgetEmpty:
return True
elif w == self.widgetGeoserver:
server = self.createGeoserverServer()
elif w == self.widgetMapserver:
server = self.createMapserverServer()
elif w == self.widgetPostgis:
server = self.createPostgisServer()
elif w == self.widgetMetadataCatalog:
server = self.createGeonetworkServer()
elif w == self.widgetGeocatLive:
server = self.createGeocatLiveServer()
if server is None:
return False
else:
if self.currentServer is not None:
removeServer(self.currentServer.name)
item = self.itemFromServerName(self.currentServer.name)
self.listServers.itemWidget(item).setServerName(server.name)
addServer(server)
self.currentServer = server
return True
def itemFromServerName(self, name):
for i in range(self.listServers.count()):
item = self.listServers.item(i)
if name == self.listServers.itemWidget(item).serverName():
return item
def createGeoserverServer(self):
##TODO check validity of name and values
name = self.txtGeoserverName.text().strip()
url = self.txtGeoserverUrl.text().strip()
if self.chkManagedWorkspace.isChecked():
workspace = None
else:
workspace = self.txtGeoserverWorkspace.text().strip()
authid = self.geoserverAuth.configId()
if self.radioUploadData.isChecked():
storage = GeoserverServer.UPLOAD_DATA
postgisdb = None
else:
storage = GeoserverServer.STORE_IN_POSTGIS
postgisdb = self.comboDatastore.currentText()
if "" in [name, url, workspace]:
return None
server = GeoserverServer(name, url, authid, storage, workspace,
postgisdb)
return server
def createPostgisServer(self):
##TODO check validity of name and values
name = self.txtPostgisName.text()
host = self.txtPostgisServerAddress.text()
port = self.txtPostgisPort.text()
schema = self.txtPostgisSchema.text()
database = self.txtPostgisDatabase.text()
authid = self.postgisAuth.configId()
server = PostgisServer(name, authid, host, port, schema, database)
return server
def createGeonetworkServer(self):
##TODO check validity of name and values
name = self.txtCswName.text()
node = self.txtCswNode.text()
authid = self.cswAuth.configId()
url = self.txtCswUrl.text()
profile = self.comboMetadataProfile.currentIndex()
server = GeonetworkServer(name, url, authid, profile, node)
return server
def createMapserverServer(self):
##TODO check validity of name and values
name = self.txtMapserverName.text()
authid = self.mapserverAuth.configId()
host = self.txtMapserverHost.text()
try:
port = int(self.txtMapserverPort.text())
except:
return None
local = self.radioLocalPath.isChecked()
if local:
folder = self.fileMapserver.filePath()
else:
folder = self.txtRemoteFolder.text()
url = self.txtMapserverUrl.text()
servicesPath = self.txtMapServicesPath.text()
projFolder = self.txtProjFolder.text()
server = MapserverServer(name, url, local, folder, authid, host, port,
servicesPath, projFolder)
return server
def createGeocatLiveServer(self):
name = self.txtGeocatLiveName.text()
geoserverAuthid = self.geocatLiveGeoserverAuth.configId()
geonetworkAuthid = self.geocatLiveGeonetworkAuth.configId()
userid = self.txtGeocatLiveIdentifier.text()
server = GeocatLiveServer(name, userid, geoserverAuthid,
geonetworkAuthid)
return server
def addAuthWidgets(self):
self.geoserverAuth = QgsAuthConfigSelect()
self.geoserverAuth.selectedConfigIdChanged.connect(
self._setCurrentServerHasChanges)
layout = QHBoxLayout()
layout.setMargin(0)
layout.addWidget(self.geoserverAuth)
self.geoserverAuthWidget.setLayout(layout)
self.geoserverAuthWidget.setFixedHeight(self.txtGeoserverUrl.height())
self.mapserverAuth = QgsAuthConfigSelect()
self.mapserverAuth.selectedConfigIdChanged.connect(
self._setCurrentServerHasChanges)
layout = QHBoxLayout()
layout.setMargin(0)
layout.addWidget(self.mapserverAuth)
self.mapserverAuthWidget.setLayout(layout)
self.mapserverAuthWidget.setFixedHeight(self.txtGeoserverUrl.height())
self.postgisAuth = QgsAuthConfigSelect()
self.postgisAuth.selectedConfigIdChanged.connect(
self._setCurrentServerHasChanges)
layout = QHBoxLayout()
layout.setMargin(0)
layout.addWidget(self.postgisAuth)
self.postgisAuthWidget.setLayout(layout)
self.postgisAuthWidget.setFixedHeight(self.txtGeoserverUrl.height())
self.cswAuth = QgsAuthConfigSelect()
self.cswAuth.selectedConfigIdChanged.connect(
self._setCurrentServerHasChanges)
layout = QHBoxLayout()
layout.setMargin(0)
layout.addWidget(self.cswAuth)
self.cswAuthWidget.setLayout(layout)
self.cswAuthWidget.setFixedHeight(self.txtGeoserverUrl.height())
self.geocatLiveGeoserverAuth = QgsAuthConfigSelect()
self.geocatLiveGeoserverAuth.selectedConfigIdChanged.connect(
self._setCurrentServerHasChanges)
layout = QHBoxLayout()
layout.setMargin(0)
layout.addWidget(self.geocatLiveGeoserverAuth)
self.geocatLiveGeoserverAuthWidget.setLayout(layout)
self.geocatLiveGeoserverAuthWidget.setFixedHeight(
self.txtGeoserverUrl.height())
self.geocatLiveGeonetworkAuth = QgsAuthConfigSelect()
self.geocatLiveGeonetworkAuth.selectedConfigIdChanged.connect(
self._setCurrentServerHasChanges)
layout = QHBoxLayout()
layout.setMargin(0)
layout.addWidget(self.geocatLiveGeonetworkAuth)
self.geocatLiveGeonetworkAuthWidget.setLayout(layout)
self.geocatLiveGeonetworkAuthWidget.setFixedHeight(
self.txtGeoserverUrl.height())
def addMenuToButtonNew(self):
menu = QMenu()
menu.addAction("GeoServer",
lambda: self._addServer("GeoServer", GeoserverServer))
menu.addAction("MapServer",
lambda: self._addServer("MapServer", MapserverServer))
menu.addAction(
"GeoCat Live",
lambda: self._addServer("GeoCat Live", GeocatLiveServer))
menu.addAction("GeoNetwork",
lambda: self._addServer("GeoNetwork", GeonetworkServer))
#menu.addAction("CSW", lambda: self._addServer("CSW", CswServer))
menu.addAction("PostGIS",
lambda: self._addServer("PostGIS", PostgisServer))
self.buttonNew.setMenu(menu)
def buttonRemoveClicked(self):
item = self.listServers.currentItem()
if item is None:
return
name = self.listServers.itemWidget(item).serverName()
removeServer(name)
self.listServers.takeItem(self.listServers.currentRow())
self.listServers.setCurrentItem(None)
def populateServers(self):
self.listServers.clear()
servers = allServers().values()
for server in servers:
self.addServerItem(server)
def addServerItem(self, server):
widget = ServerItemWidget(server)
item = QListWidgetItem(self.listServers)
item.setSizeHint(widget.sizeHint())
self.listServers.addItem(item)
self.listServers.setItemWidget(item, widget)
return item
def _addServer(self, name, clazz):
if self.currentServerHasChanges:
self.bar.pushMessage(
self.tr("Save changes to current server before creating one"),
level=Qgis.Warning,
duration=5)
else:
name = self.getNewName(name)
server = clazz(name)
addServer(server)
self.setCurrentServer(server)
item = self.addServerItem(server)
self.listServers.setCurrentItem(item)
def populatePostgisCombo(self):
self.comboDatastore.clear()
servers = allServers().values()
for s in servers:
if isinstance(s, PostgisServer):
self.comboDatastore.addItem(s.name)
def _setCurrentServerHasChanges(self):
self.currentServerHasChanges = True
def setCurrentServer(self, server):
self.currentServer = server
if server is None:
self.stackedWidget.setCurrentWidget(self.widgetEmpty)
elif isinstance(server, GeoserverServer):
self.stackedWidget.setCurrentWidget(self.widgetGeoserver)
self.txtGeoserverName.setText(server.name)
self.txtGeoserverUrl.setText(server.url)
if server.workspace is None:
self.txtGeoserverWorkspace.setText("")
self.chkManagedWorkspace.setChecked(True)
else:
self.txtGeoserverWorkspace.setText(server.workspace)
self.chkManagedWorkspace.setChecked(False)
self.geoserverAuth.setConfigId(server.authid)
self.populatePostgisCombo()
if server.postgisdb is not None:
self.comboDatastore.setCurrentText(server.postgisdb)
self.radioUploadData.setChecked(
server.storage == server.UPLOAD_DATA)
self.radioStoreInPostgis.setChecked(
server.storage == server.STORE_IN_POSTGIS)
elif isinstance(server, MapserverServer):
self.stackedWidget.setCurrentWidget(self.widgetMapserver)
self.txtMapserverName.setText(server.name)
self.fileMapserver.setFilePath(server.folder)
self.txtRemoteFolder.setText(server.folder)
self.txtMapserverHost.setText(server.host)
self.txtMapserverPort.setText(str(server.port))
self.mapserverAuth.setConfigId(server.authid)
self.txtMapserverUrl.setText(server.url)
self.txtMapServicesPath.setText(server.servicesPath)
self.txtProjFolder.setText(server.projFolder)
self.radioLocalPath.setChecked(server.useLocalFolder)
self.radioFtp.setChecked(not server.useLocalFolder)
self.mapserverStorageChanged(server.useLocalFolder)
elif isinstance(server, PostgisServer):
self.stackedWidget.setCurrentWidget(self.widgetPostgis)
self.txtPostgisName.setText(server.name)
self.txtPostgisDatabase.setText(server.database)
self.txtPostgisPort.setText(server.port)
self.txtPostgisServerAddress.setText(server.host)
self.txtPostgisSchema.setText(server.schema)
self.postgisAuth.setConfigId(server.authid)
elif isinstance(server, (GeonetworkServer, CswServer)):
self.stackedWidget.setCurrentWidget(self.widgetMetadataCatalog)
self.txtCswName.setText(server.name)
self.txtCswNode.setText(server.node)
self.txtCswUrl.setText(server.url)
self.cswAuth.setConfigId(server.authid)
self.comboMetadataProfile.setCurrentIndex(server.profile)
elif isinstance(server, GeocatLiveServer):
self.stackedWidget.setCurrentWidget(self.widgetGeocatLive)
self.txtGeocatLiveName.setText(server.name)
self.txtGeocatLiveIdentifier.setText(server.userid)
self.geocatLiveGeoserverAuth.setConfigId(server.geoserverAuthid)
self.geocatLiveGeonetworkAuth.setConfigId(server.geonetworkAuthid)
self.currentServerHasChanges = False
def getNewName(self, name):
servers = list(allServers().keys())
i = 1
while True:
n = name + str(i)
if n not in servers:
return n
else:
i += 1
def saveButtonClicked(self):
if self.saveCurrentServer():
self.currentServerHasChanges = False
else:
self.bar.pushMessage(self.tr("Error"),
self.tr("Wrong values in current item"),
level=Qgis.Warning,
duration=5)
def onClose(self, evt):
if self.currentServerHasChanges:
res = QMessageBox.question(
self, self.tr("Servers"),
self.
tr("Do you want to close without saving the current changes?"),
QMessageBox.Cancel | QMessageBox.No | QMessageBox.Yes,
QMessageBox.Yes)
if res == QMessageBox.Yes:
evt.accept()
else:
evt.ignore()
else:
evt.accept()
class GeoNetworkWidget(ServerWidgetBase, BASE, WIDGET):
def __init__(self, parent, server_type):
super().__init__(parent, server_type)
self.setupUi(self)
self.geonetworkAuth = QgsAuthConfigSelect()
self.geonetworkAuth.selectedConfigIdChanged.connect(self.setDirty)
self.addAuthWidget()
self.txtGeonetworkName.textChanged.connect(self.setDirty)
self.txtGeonetworkNode.textChanged.connect(self.setDirty)
self.txtGeonetworkUrl.textChanged.connect(self.setDirty)
self.populateProfileCombo()
self.comboMetadataProfile.currentIndexChanged.connect(self.setDirty)
# TODO: implement profile stuff
self.comboMetadataProfile.setVisible(False)
self.labelMetadataProfile.setVisible(False)
def createServerInstance(self):
""" Reads the settings form fields and returns a new server instance with these settings. """
try:
name = self.txtGeonetworkName.text().strip()
url = self.txtGeonetworkUrl.text().strip()
if not name:
raise RuntimeError(
f'missing {self.serverType.getLabel()} name')
if not url:
raise RuntimeError(f'missing {self.serverType.getLabel()} URL')
return self.serverType(
name=name,
authid=self.geonetworkAuth.configId() or None,
url=url,
# profile=self.comboMetadataProfile.currentIndex(),
node=self.txtGeonetworkNode.text().strip() or 'srv')
except Exception as e:
self.parent.logError(
f"Failed to create {self.serverType.getLabel()} instance: {e}")
return None
def newFromName(self, name: str):
""" Sets the name field and keeps all others empty. """
self.txtGeonetworkName.setText(name)
self.txtGeonetworkUrl.clear()
self.txtGeonetworkNode.clear()
self.geonetworkAuth.setConfigId(None)
# Reset profile combobox
self.comboMetadataProfile.blockSignals(True)
self.comboMetadataProfile.setCurrentIndex(GeoNetworkProfiles.DEFAULT)
self.comboMetadataProfile.blockSignals(False)
def loadFromInstance(self, server):
""" Populates the form fields with the values from the given server instance. """
self.txtGeonetworkName.setText(server.serverName)
self.txtGeonetworkUrl.setText(server.baseUrl)
self.geonetworkAuth.setConfigId(server.authId)
# Reset profile combobox
self.comboMetadataProfile.blockSignals(True)
self.comboMetadataProfile.setCurrentIndex(server.profile)
self.comboMetadataProfile.blockSignals(False)
# After the data has loaded, the form is "clean"
self.setClean()
def addAuthWidget(self):
layout = QHBoxLayout()
layout.setContentsMargins(0, 3, 0, 0)
layout.addWidget(self.geonetworkAuth)
self.geonetworkAuthWidget.setLayout(layout)
self.geonetworkAuthWidget.setFixedHeight(
self.txtGeonetworkUrl.height())
def populateProfileCombo(self):
self.comboMetadataProfile.clear()
self.comboMetadataProfile.addItems(GeoNetworkProfiles.values())
class ALKISConf(QDialog, ConfBase):
def __init__(self, plugin):
QDialog.__init__(self)
self.setupUi(self)
self.plugin = plugin
self.settings = plugin.settings
self.settings.loadSettings()
self.leSERVICE.setText(self.settings.service)
self.leHOST.setText(self.settings.host)
self.lePORT.setText(self.settings.port)
self.leDBNAME.setText(self.settings.dbname)
self.leSCHEMA.setText(self.settings.schema)
self.leUID.setText(self.settings.uid)
self.lePWD.setText(self.settings.pwd)
self.cbxSignaturkatalog.setEnabled(False)
if hasattr(qgis.gui, 'QgsAuthConfigSelect'):
self.authCfgSelect = QgsAuthConfigSelect(self, "postgres")
self.tabWidget.insertTab(1, self.authCfgSelect, "Konfigurationen")
authcfg = self.settings.authcfg
if authcfg:
self.tabWidget.setCurrentIndex(1)
self.authCfgSelect.setConfigId(authcfg)
self.leUMNPath.setText(self.settings.umnpath)
self.pbUMNBrowse.clicked.connect(self.browseUMNPath)
self.leUMNTemplate.setText(self.settings.umntemplate)
self.teFussnote.setPlainText(self.settings.footnote)
self.loadModels(False)
self.bb.accepted.connect(self.accept)
self.bb.rejected.connect(self.reject)
self.bb.addButton("Modelle laden", QDialogButtonBox.ActionRole).clicked.connect(self.loadModels)
self.bb.addButton("Layer einbinden", QDialogButtonBox.ActionRole).clicked.connect(self.loadLayers)
self.restoreGeometry(QSettings("norBIT", "norGIS-ALKIS-Erweiterung").value("confgeom", QByteArray(), type=QByteArray))
def done(self, r):
QSettings("norBIT", "norGIS-ALKIS-Erweiterung").setValue("confgeom", self.saveGeometry())
return QDialog.done(self, r)
def loadModels(self, error=True):
self.settings.servicE = self.leSERVICE.text()
self.settings.host = self.leHOST.text()
self.settings.port = self.lePORT.text()
self.settings.dbname = self.leDBNAME.text()
self.settings.schema = self.leSCHEMA.text()
self.settings.uid = self.leUID.text()
self.settings.pwd = self.lePWD.text()
if hasattr(qgis.gui, 'QgsAuthConfigSelect'):
self.settings.authcfg = self.authCfgSelect.configId()
self.twModellarten.clearContents()
self.cbxSignaturkatalog.clear()
(db, conninfo) = self.plugin.opendb()
if not db:
if error:
QMessageBox.critical(None, "ALKIS", u"Datenbankverbindung schlug fehl.")
self.twModellarten.clearContents()
self.twModellarten.setDisabled(True)
self.twModellarten.setRowCount(0)
self.settings.load()
return
modelle = self.settings.modellarten
if modelle is None:
modelle = ['DLKM', 'DKKM1000']
qry = QSqlQuery(db)
if qry.exec_("SELECT 1 FROM information_schema.tables WHERE table_schema={} AND table_name='po_modelle'".format(quote(self.plugin.settings.schema))) and qry.next():
sql = "SELECT modell,n FROM po_modelle WHERE modell IS NOT NULL ORDER BY n DESC"
else:
sql = """
SELECT modell,count(*)
FROM (
SELECT unnest(modell) AS modell FROM po_points UNION ALL
SELECT unnest(modell) AS modell FROM po_lines UNION ALL
SELECT unnest(modell) AS modell FROM po_polygons UNION ALL
SELECT unnest(modell) AS modell from po_labels
) AS foo
WHERE modell IS NOT NULL
GROUP BY modell
ORDER BY count(*) DESC
"""
if qry.exec_(sql):
res = {}
while qry.next():
res[qry.value(0)] = qry.value(1)
self.twModellarten.setRowCount(len(res))
i = 0
for k, n in sorted(iter(list(res.items())), key=operator.itemgetter(1), reverse=True):
item = QTableWidgetItem(k)
item.setCheckState(Qt.Checked if (item.text() in modelle) else Qt.Unchecked)
self.twModellarten.setItem(i, 0, item)
item = QTableWidgetItem(str(n))
self.twModellarten.setItem(i, 1, item)
i += 1
self.twModellarten.resizeColumnsToContents()
self.twModellarten.setEnabled(True)
else:
self.twModellarten.clearContents()
self.twModellarten.setDisabled(True)
self.twModellarten.setRowCount(0)
if qry.exec_("SELECT id,name FROM alkis_signaturkataloge"):
while qry.next():
self.cbxSignaturkatalog.addItem(qry.value(1), int(qry.value(0)))
self.cbxSignaturkatalog.setEnabled(True)
else:
self.cbxSignaturkatalog.addItem(u"Farbe", -1)
self.cbxSignaturkatalog.setCurrentIndex(max([0, self.cbxSignaturkatalog.findData(self.settings.signaturkatalog)]))
self.settings.load()
def saveSettings(self):
self.settings.service = self.leSERVICE.text()
self.settings.host = self.leHOST.text()
self.settings.port = self.lePORT.text()
self.settings.dbname = self.leDBNAME.text()
self.settings.schema = self.leSCHEMA.text()
self.settings.uid = self.leUID.text()
self.settings.pwd = self.lePWD.text()
if hasattr(qgis.gui, 'QgsAuthConfigSelect'):
self.settings.authcfg = self.authCfgSelect.configId()
self.settings.umnpath = self.leUMNPath.text()
self.settings.umntemplate = self.leUMNTemplate.text()
self.settings.footnote = self.teFussnote.toPlainText()
modelle = []
if self.twModellarten.isEnabled():
for i in range(self.twModellarten.rowCount()):
item = self.twModellarten.item(i, 0)
if item.checkState() == Qt.Checked:
modelle.append(item.text())
self.settings.modellarten = modelle
self.settings.signaturkatalog = self.cbxSignaturkatalog.itemData(self.cbxSignaturkatalog.currentIndex())
self.settings.saveSettings()
def loadLayers(self):
self.saveSettings()
self.plugin.run()
self.settings.load()
QDialog.accept(self)
def accept(self):
self.saveSettings()
self.settings.load()
QDialog.accept(self)
def browseUMNPath(self):
path = self.leUMNPath.text()
path = QFileDialog.getExistingDirectory(self, u"UMN-Pfad wählen", path)
if path != "":
self.leUMNPath.setText(path)
