def listSpatialiteConnections(): """List SpatiaLite connections stored in QGIS settings, and return dict with keys: path (list),name(list) and index (int) of last used DB (index) (-1 by default)""" res = dict() res['idx'] = 0 settings = QSettings() settings.beginGroup('/SpatiaLite/connections') res['name'] = [str(item) for item in settings.childGroups()] res['path'] = [ str(settings.value(u'%s/sqlitepath' % str(item))) for item in settings.childGroups() ] settings.endGroup() # case: no connection available if len(res['name']) > 0: # case: connections available # try to select directly last opened dataBase () try: last_db = settings.value(u'/SpatiaLite/connections/selected') last_db = last_db.split('@', 1)[1] # get last connexion index res['idx'] = res['name'].index(last_db) except: res['idx'] = 0 # return the result even if empty return res
def load_directories(self): """Load directories of repository registered in settings.""" self._directories = {} settings = QSettings() settings.beginGroup(repo_settings_group()) # Write online directory first to QSettings if needed for online_dir_name in self._online_directories: repo_present = False for repo_name in settings.childGroups(): url = settings.value(repo_name + '/url', '', type=unicode) if url == self._online_directories[online_dir_name]: repo_present = True break if not repo_present: self.add_directory( online_dir_name, self._online_directories[online_dir_name]) for repo_name in settings.childGroups(): self._directories[repo_name] = {} url = settings.value( repo_name + '/url', '', type=unicode) self._directories[repo_name]['url'] = url auth_cfg = settings.value( repo_name + '/auth_cfg', '', type=unicode).strip() self._directories[repo_name]['auth_cfg'] = auth_cfg settings.endGroup()
def load(self): """ populate the mRepositories dict""" self.mRepositories = {} settings = QSettings() settings.beginGroup(reposGroup) # first, update repositories in QSettings if needed officialRepoPresent = False for key in settings.childGroups(): url = settings.value(key + "/url", "", type=unicode) if url == officialRepo[1]: officialRepoPresent = True if url == officialRepo[2]: settings.setValue(key + "/url", officialRepo[1]) # correct a depreciated url officialRepoPresent = True if not officialRepoPresent: settings.setValue(officialRepo[0] + "/url", officialRepo[1]) for key in settings.childGroups(): self.mRepositories[key] = {} self.mRepositories[key]["url"] = settings.value(key + "/url", "", type=unicode) self.mRepositories[key]["authcfg"] = settings.value(key + "/authcfg", "", type=unicode) self.mRepositories[key]["enabled"] = settings.value(key + "/enabled", True, type=bool) self.mRepositories[key]["valid"] = settings.value(key + "/valid", True, type=bool) self.mRepositories[key]["Relay"] = Relay(key) self.mRepositories[key]["xmlData"] = None self.mRepositories[key]["state"] = 0 self.mRepositories[key]["error"] = "" settings.endGroup()
def __init__(self, parent, tablename): super(PostgisTableSelector, self).__init__(parent) self.connection = None self.table = None self.schema = None self.setupUi(self) settings = QSettings() settings.beginGroup('/PostgreSQL/connections/') names = settings.childGroups() settings.endGroup() for n in names: item = ConnectionItem(n) self.treeConnections.addTopLevelItem(item) def itemExpanded(item): try: item.populateSchemas() except: pass self.treeConnections.itemExpanded.connect(itemExpanded) self.textTableName.setText(tablename) self.buttonBox.accepted.connect(self.okPressed) self.buttonBox.rejected.connect(self.cancelPressed)
def __init__(self, iface): self.iface = iface QDialog.__init__(self) # Set up the user interface from Designer. self.ui = uic.loadUi(ui_file, self) self.configFilePath = os.path.join(os.path.dirname(__file__), 'config.cfg') self.defFlags = Qt.NoItemFlags | Qt.ItemIsEnabled | Qt.ItemIsEditable | Qt.ItemIsSelectable # Populate the PostGIS connection combo with the available connections # Determine our current preference s = QSettings() selectedConnection = str(s.value("constraintchecker/postgisConnection", '')) s.beginGroup('PostgreSQL/connections') i = 0 for connectionName in s.childGroups(): self.postgisConnectionComboBox.addItem(connectionName) if connectionName == selectedConnection: # Select this preference in the combo if exists self.postgisConnectionComboBox.setCurrentIndex(i) i += 1 s.endGroup() # Now read the configuration file (if it exists) into the table widget try: self.readConfiguration() except: pass
def getQGISDbs(portlast=False): """Return all PostGIS connection settings stored in QGIS :return: connection dict() with name and other settings """ settings = QSettings() settings.beginGroup('/PostgreSQL/connections') named_dbs = settings.childGroups() all_info = [ i.split("/") + [str(settings.value(i))] for i in settings.allKeys() if settings.value(i) != NULL and settings.value(i) != '' ] query_columns = [ 'name', 'host', 'service', 'password', 'username', 'port', 'database' ] if portlast: query_columns = [ 'name', 'host', 'service', 'password', 'username', 'database', 'port' ] all_info = [ i for i in all_info if i[0] in named_dbs and i[2] != NULL and i[1] in query_columns ] dbs = dict([k, dict([i[1:] for i in list(g)])] for k, g in itertools.groupby(sorted(all_info), operator.itemgetter(0))) settings.endGroup() return dbs
def on_removeMissingPushButton_clicked(self): ''' Remove missing databases from QSetttings ''' servers = self.serverWidget.getServers() settings = QSettings() settings.beginGroup('PostgreSQL/connections') candidates = settings.childGroups() settings.endGroup() removedConn = [] dbList = [] try: dbList = self.serverWidget.abstractDb.getDbsFromServer() except Exception as e: QMessageBox.critical(self, self.tr('Critical!'), ':'.join(e.args)) for candidate in candidates: candidateSettings = QSettings() candidateSettings.beginGroup('PostgreSQL/connections/'+candidate) candidateDb = candidateSettings.value('database') if candidateDb not in dbList: self.removeConnections(candidate, removedConn) if len(removedConn)>0: msg = self.tr('\nThe following databases connections were removed successfully:\n')+', '.join(removedConn) else: msg = self.tr('No connections were removed.') QMessageBox.warning(self, self.tr("Warning!"), msg)
class PgsqlConnectionsModel(QAbstractItemModel): def __init__(self, parent=None): super(PgsqlConnectionsModel, self).__init__(parent) self._settings = QSettings() self._settings.beginGroup('/PostgreSQL/connections/') def _groups(self): return self._settings.childGroups() def parent(self, index): return QModelIndex() def index(self, row, column, parent): return self.createIndex(row, column) def rowCount(self, parent): return len(self._groups()) def columnCount(self, parent): return 1 def data(self, index, role=Qt.DisplayRole): return self._groups()[index.row()]
def listPostgisConnectionNames(): """ Retrieve a list of PostgreSQL connection names :return: connections - list of strings """ settings = QSettings() settings.beginGroup('/PostgreSQL/connections') connection_names = [str(item) for item in settings.childGroups()] return connection_names
def dbConnectionList(self): connection_names = [] settings = QSettings() settings.beginGroup(u"/PostgreSQL/connections") for name in settings.childGroups(): connection_names.append(name) settings.endGroup() return connection_names
def _postgres_connections(self): """ Return the list of saved PostgreSQL connections. """ settings = QSettings() settings.beginGroup("PostgreSQL/connections") return [name for name in settings.childGroups()]
def connections(self): # get the list of connections conn_list = [] settings = QSettings() settings.beginGroup(self.connectionSettingsKey()) for name in settings.childGroups(): conn_list.append(createDbPlugin(self.typeName(), name)) settings.endGroup() return conn_list
def getServers(self): """ Gets server from QSettings """ settings = QSettings() settings.beginGroup('PostgreSQL/servers') currentConnections = settings.childGroups() settings.endGroup() return currentConnections
def getAvailableConnections(self): connections = [] settings = QSettings() settings.beginGroup("/%s/connections" % self.getSettingsKey()) keys = settings.childGroups() for name in keys: connections.append(Connection.ConnectionAction(name, self.getTypeName())) settings.endGroup() return connections
def getAvailableConnections(self): connections = [] settings = QSettings() settings.beginGroup("/%s/connections" % self.getSettingsKey()) keys = settings.childGroups() for name in keys: connections.append( Connection.ConnectionAction(name, self.getTypeName())) settings.endGroup() return connections
def group_children(self): """ :return: Names of the child groups in the path specified in the constructor. :rtype: list """ settings = QSettings() settings.beginGroup(self.groupPath) group_children = settings.childGroups() settings.endGroup() return group_children
def items(self): settings = QSettings() settings.beginGroup('/PostgreSQL/connections/') items = [(group, group) for group in settings.childGroups()] if self.dialogType == DIALOG_MODELER: strings = self.dialog.getAvailableValuesOfType([ ParameterString, ParameterNumber, ParameterFile, ParameterTableField, ParameterExpression ], OutputString) items = items + [(self.dialog.resolveValueDescription(s), s) for s in strings] return items
def getCustomSizesDict(self): #get custom sizes from qsettings settings = QSettings() settings.beginGroup('DSGTools/CustomSizes/') currentSettings = settings.childGroups() settings.endGroup() customSizesDict = dict() #get each parameter for settingName in currentSettings: customSizesDict[settingName] = dict() settings = QSettings() settings.beginGroup('DSGTools/CustomSizes/' + settingName) customSizesDict[settingName]['shape'] = settings.value('shape') customSizesDict[settingName]['value'] = settings.value('value') settings.endGroup() return customSizesDict
def userPasswordFromHost(self, hostname, username): """ Gets the password of an user to a server from its name. """ settings = QSettings() settings.beginGroup('PostgreSQL/servers') connections = settings.childGroups() settings.endGroup() for connection in connections: settings.beginGroup('PostgreSQL/servers/{0}'.format(connection)) host = settings.value('host') user = settings.value('username') password = settings.value('password') settings.endGroup() if host == hostname and username == user: return password return None
def get_cloud_db_connections(db_name): connection_names = [] settings = QSettings() settings.beginGroup(u"/PostgreSQL/connections") for name in settings.childGroups(): settings.beginGroup(name) # host might be NoneType, which causes str conversion to fail try: db = settings.value("database") host = settings.value("host") if db == db_name and host in DbConnectionCfg.CLOUD_DB_HOSTS: connection_names.append(name) except: pass settings.endGroup() settings.endGroup() return connection_names
def selectOutput(self): if isinstance(self.output, OutputDirectory): self.selectDirectory() else: popupMenu = QMenu() if isinstance(self.output, OutputVector) \ and self.alg.provider.supportsNonFileBasedOutput(): # use memory layers for temporary files if supported actionSaveToTempFile = QAction( self.tr('Create temporary layer'), self.btnSelect) else: actionSaveToTempFile = QAction( self.tr('Save to a temporary file'), self.btnSelect) actionSaveToTempFile.triggered.connect(self.saveToTemporaryFile) popupMenu.addAction(actionSaveToTempFile) actionSaveToFile = QAction(self.tr('Save to file...'), self.btnSelect) actionSaveToFile.triggered.connect(self.selectFile) popupMenu.addAction(actionSaveToFile) actionShowExpressionsBuilder = QAction( self.tr('Use expression...'), self.btnSelect) actionShowExpressionsBuilder.triggered.connect( self.showExpressionsBuilder) popupMenu.addAction(actionShowExpressionsBuilder) if isinstance(self.output, OutputVector) \ and self.alg.provider.supportsNonFileBasedOutput(): actionSaveToSpatialite = QAction( self.tr('Save to Spatialite table...'), self.btnSelect) actionSaveToSpatialite.triggered.connect(self.saveToSpatialite) popupMenu.addAction(actionSaveToSpatialite) actionSaveToPostGIS = QAction( self.tr('Save to PostGIS table...'), self.btnSelect) actionSaveToPostGIS.triggered.connect(self.saveToPostGIS) settings = QSettings() settings.beginGroup('/PostgreSQL/connections/') names = settings.childGroups() settings.endGroup() actionSaveToPostGIS.setEnabled(bool(names)) popupMenu.addAction(actionSaveToPostGIS) popupMenu.exec_(QCursor.pos())
def readSearches(self): searches = {} settings = QSettings() settings.beginGroup("/plugins/%s/postgis_search" % self.settings.plugin_name) for searchId in settings.childGroups(): settings.beginGroup(searchId) searchName = settings.value('searchName') expression = settings.value('expression') priority = settings.value('priority', type=int) srid = settings.value('srid') project = searchId in self.settings.value("postgisSearches") searches[searchId] = PostgisSearch(searchId, searchName, expression, priority, srid, project) settings.endGroup() settings.endGroup() return searches
def selectOutput(self): if isinstance(self.output, OutputDirectory): self.selectDirectory() else: popupMenu = QMenu() if isinstance(self.output, OutputVector) \ and self.alg.provider.supportsNonFileBasedOutput(): # use memory layers for temporary layers if supported actionSaveToTemp = QAction( self.tr('Create temporary layer'), self.btnSelect) else: actionSaveToTemp = QAction( self.tr('Save to a temporary file'), self.btnSelect) actionSaveToTemp.triggered.connect(self.saveToTemporary) popupMenu.addAction(actionSaveToTemp) actionSaveToFile = QAction( self.tr('Save to file...'), self.btnSelect) actionSaveToFile.triggered.connect(self.selectFile) popupMenu.addAction(actionSaveToFile) actionShowExpressionsBuilder = QAction( self.tr('Use expression...'), self.btnSelect) actionShowExpressionsBuilder.triggered.connect(self.showExpressionsBuilder) popupMenu.addAction(actionShowExpressionsBuilder) if isinstance(self.output, OutputVector) \ and self.alg.provider.supportsNonFileBasedOutput(): actionSaveToSpatialite = QAction( self.tr('Save to Spatialite table...'), self.btnSelect) actionSaveToSpatialite.triggered.connect(self.saveToSpatialite) popupMenu.addAction(actionSaveToSpatialite) actionSaveToPostGIS = QAction( self.tr('Save to PostGIS table...'), self.btnSelect) actionSaveToPostGIS.triggered.connect(self.saveToPostGIS) settings = QSettings() settings.beginGroup('/PostgreSQL/connections/') names = settings.childGroups() settings.endGroup() actionSaveToPostGIS.setEnabled(bool(names)) popupMenu.addAction(actionSaveToPostGIS) popupMenu.exec_(QCursor.pos())
def setDefaultConnectionParameters(self, connection, host, port, user, password): defaultConnectionDict = dict() if host and port and user and password: defaultConnectionDict['host'] = host defaultConnectionDict['port'] = port defaultConnectionDict['user'] = user defaultConnectionDict['password'] = password # set all connection on QSettings to not default and this connetion to default settings = QSettings() settings.beginGroup('PostgreSQL/servers') connections = settings.childGroups() settings.endGroup() for conn in connections: settings.beginGroup('PostgreSQL/servers/{0}'.format(conn)) settings.setValue('isDefault', conn == connection) settings.endGroup() else: defaultConnectionDict = dict() return defaultConnectionDict
def read(self, items): """ Get the value of the user defined items from the STDM registry tree param items: List of registry keys to fetch. type items: list """ userKeys = {} settings = QSettings() settings.beginGroup("/") groups = settings.childGroups() for group in groups: if str(group) == self._base_group(): for t in items: tKey = self.groupPath + "/" + t if settings.contains(tKey): tValue = settings.value(tKey) userKeys[t] = tValue break return userKeys
def getPostgisConnectionSettings(): """Return all PostGIS connection settings stored in QGIS :return: connection dict() with name and other settings """ con_settings = [] settings = QSettings() settings.beginGroup('/PostgreSQL/connections') for item in settings.childGroups(): con = dict() con['name'] = str(item) con['service'] = str(settings.value(u'%s/service' % str(item))) con['host'] = str(settings.value(u'%s/host' % str(item))) con['port'] = str(settings.value(u'%s/port' % str(item))) con['database'] = str(settings.value(u'%s/database' % str(item))) con['username'] = str(settings.value(u'%s/username' % str(item))) con['password'] = str(settings.value(u'%s/password' % str(item))) con_settings.append(con) settings.endGroup() if len(con_settings) < 1: con_settings = None return con_settings
def setDatabaseComboBox(self): self.dockwidget.combo_database.clear() s = QSettings() s.beginGroup("PostgreSQL/connections") db_names = s.childGroups() self.db_params = dict() if len(db_names) == 0: self.log("No Database Connections Available") self.set_execute_enabled(False) else: for name in db_names: self.db_params[name] = { 'host': s.value(f"{name}/host"), 'port': s.value(f"{name}/port"), 'database': s.value(f"{name}/database"), 'username': s.value(f"{name}/username"), 'password': s.value(f"{name}/password") } self.dockwidget.combo_database.addItem(name) self.onDbChanged(db_names[0]) self.set_execute_enabled(True) s.endGroup()
class MetaSearchDialog(QDialog, BASE_CLASS): """main dialogue""" def __init__(self, iface): """init window""" QDialog.__init__(self) self.setupUi(self) self.iface = iface self.map = iface.mapCanvas() self.settings = QSettings() self.catalog = None self.catalog_url = None self.context = StaticContext() version = self.context.metadata.get('general', 'version') self.setWindowTitle('MetaSearch %s' % version) self.rubber_band = QgsRubberBand(self.map, True) # True = a polygon self.rubber_band.setColor(QColor(255, 0, 0, 75)) self.rubber_band.setWidth(5) # form inputs self.startfrom = 0 self.maxrecords = 10 self.timeout = 10 self.constraints = [] # Servers tab self.cmbConnectionsServices.activated.connect(self.save_connection) self.cmbConnectionsSearch.activated.connect(self.save_connection) self.btnServerInfo.clicked.connect(self.connection_info) self.btnAddDefault.clicked.connect(self.add_default_connections) self.btnCapabilities.clicked.connect(self.show_xml) self.tabWidget.currentChanged.connect(self.populate_connection_list) # server management buttons self.btnNew.clicked.connect(self.add_connection) self.btnEdit.clicked.connect(self.edit_connection) self.btnDelete.clicked.connect(self.delete_connection) self.btnLoad.clicked.connect(self.load_connections) self.btnSave.clicked.connect(save_connections) # Search tab self.treeRecords.itemSelectionChanged.connect(self.record_clicked) self.treeRecords.itemDoubleClicked.connect(self.show_metadata) self.btnSearch.clicked.connect(self.search) self.leKeywords.returnPressed.connect(self.search) # prevent dialog from closing upon pressing enter self.buttonBox.button(QDialogButtonBox.Close).setAutoDefault(False) # launch help from button self.buttonBox.helpRequested.connect(self.help) self.btnCanvasBbox.setAutoDefault(False) self.btnCanvasBbox.clicked.connect(self.set_bbox_from_map) self.btnGlobalBbox.clicked.connect(self.set_bbox_global) # navigation buttons self.btnFirst.clicked.connect(self.navigate) self.btnPrev.clicked.connect(self.navigate) self.btnNext.clicked.connect(self.navigate) self.btnLast.clicked.connect(self.navigate) self.btnAddToWms.clicked.connect(self.add_to_ows) self.btnAddToWfs.clicked.connect(self.add_to_ows) self.btnAddToWcs.clicked.connect(self.add_to_ows) self.btnShowXml.clicked.connect(self.show_xml) # settings self.radioTitleAsk.clicked.connect(self.set_ows_save_title_ask) self.radioTitleNoAsk.clicked.connect(self.set_ows_save_title_no_ask) self.radioTempName.clicked.connect(self.set_ows_save_temp_name) self.manageGui() def manageGui(self): """open window""" self.tabWidget.setCurrentIndex(0) self.populate_connection_list() self.btnCapabilities.setEnabled(False) self.spnRecords.setValue( self.settings.value('/MetaSearch/returnRecords', 10, int)) key = '/MetaSearch/%s' % self.cmbConnectionsSearch.currentText() self.catalog_url = self.settings.value('%s/url' % key) self.set_bbox_global() self.reset_buttons() # get preferred connection save strategy from settings and set it save_strat = self.settings.value('/MetaSearch/ows_save_strategy', 'title_ask') if save_strat == 'temp_name': self.radioTempName.setChecked(True) elif save_strat == 'title_no_ask': self.radioTitleNoAsk.setChecked(True) else: self.radioTitleAsk.setChecked(True) # install proxy handler if specified in QGIS settings self.install_proxy() # Servers tab def populate_connection_list(self): """populate select box with connections""" self.settings.beginGroup('/MetaSearch/') self.cmbConnectionsServices.clear() self.cmbConnectionsServices.addItems(self.settings.childGroups()) self.cmbConnectionsSearch.clear() self.cmbConnectionsSearch.addItems(self.settings.childGroups()) self.settings.endGroup() self.set_connection_list_position() if self.cmbConnectionsServices.count() == 0: # no connections - disable various buttons state_disabled = False self.btnSave.setEnabled(state_disabled) # and start with connection tab open self.tabWidget.setCurrentIndex(1) # tell the user to add services msg = self.tr('No services/connections defined. To get ' 'started with MetaSearch, create a new ' 'connection by clicking \'New\' or click ' '\'Add default services\'.') self.textMetadata.setHtml('<p><h3>%s</h3></p>' % msg) else: # connections - enable various buttons state_disabled = True self.btnServerInfo.setEnabled(state_disabled) self.btnEdit.setEnabled(state_disabled) self.btnDelete.setEnabled(state_disabled) def set_connection_list_position(self): """set the current index to the selected connection""" to_select = self.settings.value('/MetaSearch/selected') conn_count = self.cmbConnectionsServices.count() if conn_count == 0: self.btnDelete.setEnabled(False) self.btnServerInfo.setEnabled(False) self.btnEdit.setEnabled(False) # does to_select exist in cmbConnectionsServices? exists = False for i in range(conn_count): if self.cmbConnectionsServices.itemText(i) == to_select: self.cmbConnectionsServices.setCurrentIndex(i) self.cmbConnectionsSearch.setCurrentIndex(i) exists = True break # If we couldn't find the stored item, but there are some, default # to the last item (this makes some sense when deleting items as it # allows the user to repeatidly click on delete to remove a whole # lot of items) if not exists and conn_count > 0: # If to_select is null, then the selected connection wasn't found # by QSettings, which probably means that this is the first time # the user has used CSWClient, so default to the first in the list # of connetions. Otherwise default to the last. if not to_select: current_index = 0 else: current_index = conn_count - 1 self.cmbConnectionsServices.setCurrentIndex(current_index) self.cmbConnectionsSearch.setCurrentIndex(current_index) def save_connection(self): """save connection""" caller = self.sender().objectName() if caller == 'cmbConnectionsServices': # servers tab current_text = self.cmbConnectionsServices.currentText() elif caller == 'cmbConnectionsSearch': # search tab current_text = self.cmbConnectionsSearch.currentText() self.settings.setValue('/MetaSearch/selected', current_text) key = '/MetaSearch/%s' % current_text if caller == 'cmbConnectionsSearch': # bind to service in search tab self.catalog_url = self.settings.value('%s/url' % key) if caller == 'cmbConnectionsServices': # clear server metadata self.textMetadata.clear() self.btnCapabilities.setEnabled(False) def connection_info(self): """show connection info""" current_text = self.cmbConnectionsServices.currentText() key = '/MetaSearch/%s' % current_text self.catalog_url = self.settings.value('%s/url' % key) # connect to the server if not self._get_csw(): return QApplication.restoreOverrideCursor() if self.catalog: # display service metadata self.btnCapabilities.setEnabled(True) metadata = render_template('en', self.context, self.catalog, 'service_metadata.html') style = QgsApplication.reportStyleSheet() self.textMetadata.clear() self.textMetadata.document().setDefaultStyleSheet(style) self.textMetadata.setHtml(metadata) def add_connection(self): """add new service""" conn_new = NewConnectionDialog() conn_new.setWindowTitle(self.tr('New Catalogue service')) if conn_new.exec_() == QDialog.Accepted: # add to service list self.populate_connection_list() self.textMetadata.clear() def edit_connection(self): """modify existing connection""" current_text = self.cmbConnectionsServices.currentText() url = self.settings.value('/MetaSearch/%s/url' % current_text) conn_edit = NewConnectionDialog(current_text) conn_edit.setWindowTitle(self.tr('Edit Catalogue service')) conn_edit.leName.setText(current_text) conn_edit.leURL.setText(url) if conn_edit.exec_() == QDialog.Accepted: # update service list self.populate_connection_list() def delete_connection(self): """delete connection""" current_text = self.cmbConnectionsServices.currentText() key = '/MetaSearch/%s' % current_text msg = self.tr('Remove service %s?') % current_text result = QMessageBox.information(self, self.tr('Confirm delete'), msg, QMessageBox.Ok | QMessageBox.Cancel) if result == QMessageBox.Ok: # remove service from list self.settings.remove(key) index_to_delete = self.cmbConnectionsServices.currentIndex() self.cmbConnectionsServices.removeItem(index_to_delete) self.cmbConnectionsSearch.removeItem(index_to_delete) self.set_connection_list_position() def load_connections(self): """load services from list""" ManageConnectionsDialog(1).exec_() self.populate_connection_list() def add_default_connections(self): """add default connections""" filename = os.path.join(self.context.ppath, 'resources', 'connections-default.xml') doc = get_connections_from_file(self, filename) if doc is None: return self.settings.beginGroup('/MetaSearch/') keys = self.settings.childGroups() self.settings.endGroup() for server in doc.findall('csw'): name = server.attrib.get('name') # check for duplicates if name in keys: msg = self.tr('%s exists. Overwrite?') % name res = QMessageBox.warning(self, self.tr('Loading connections'), msg, QMessageBox.Yes | QMessageBox.No) if res != QMessageBox.Yes: continue # no dups detected or overwrite is allowed key = '/MetaSearch/%s' % name self.settings.setValue('%s/url' % key, server.attrib.get('url')) self.populate_connection_list() # Settings tab def set_ows_save_title_ask(self): """save ows save strategy as save ows title, ask if duplicate""" self.settings.setValue('/MetaSearch/ows_save_strategy', 'title_ask') def set_ows_save_title_no_ask(self): """save ows save strategy as save ows title, do NOT ask if duplicate""" self.settings.setValue('/MetaSearch/ows_save_strategy', 'title_no_ask') def set_ows_save_temp_name(self): """save ows save strategy as save with a temporary name""" self.settings.setValue('/MetaSearch/ows_save_strategy', 'temp_name') # Search tab def set_bbox_from_map(self): """set bounding box from map extent""" crs = self.map.mapRenderer().destinationCrs() crsid = int(crs.authid().split(':')[1]) extent = self.map.extent() if crsid != 4326: # reproject to EPSG:4326 src = QgsCoordinateReferenceSystem(crsid) dest = QgsCoordinateReferenceSystem(4326) xform = QgsCoordinateTransform(src, dest) minxy = xform.transform(QgsPoint(extent.xMinimum(), extent.yMinimum())) maxxy = xform.transform(QgsPoint(extent.xMaximum(), extent.yMaximum())) minx, miny = minxy maxx, maxy = maxxy else: # 4326 minx = extent.xMinimum() miny = extent.yMinimum() maxx = extent.xMaximum() maxy = extent.yMaximum() self.leNorth.setText(unicode(maxy)[0:9]) self.leSouth.setText(unicode(miny)[0:9]) self.leWest.setText(unicode(minx)[0:9]) self.leEast.setText(unicode(maxx)[0:9]) def set_bbox_global(self): """set global bounding box""" self.leNorth.setText('90') self.leSouth.setText('-90') self.leWest.setText('-180') self.leEast.setText('180') def search(self): """execute search""" self.catalog = None self.constraints = [] # clear all fields and disable buttons self.lblResults.clear() self.treeRecords.clear() self.reset_buttons() # save some settings self.settings.setValue('/MetaSearch/returnRecords', self.spnRecords.cleanText()) # set current catalogue current_text = self.cmbConnectionsSearch.currentText() key = '/MetaSearch/%s' % current_text self.catalog_url = self.settings.value('%s/url' % key) # start position and number of records to return self.startfrom = 0 self.maxrecords = self.spnRecords.value() # set timeout self.timeout = self.spnTimeout.value() # bbox minx = self.leWest.text() miny = self.leSouth.text() maxx = self.leEast.text() maxy = self.leNorth.text() bbox = [minx, miny, maxx, maxy] # only apply spatial filter if bbox is not global # even for a global bbox, if a spatial filter is applied, then # the CSW server will skip records without a bbox if bbox != ['-180', '-90', '180', '90']: self.constraints.append(BBox(bbox)) # keywords if self.leKeywords.text(): # TODO: handle multiple word searches keywords = self.leKeywords.text() self.constraints.append(PropertyIsLike('csw:AnyText', keywords)) if len(self.constraints) > 1: # exclusive search (a && b) self.constraints = [self.constraints] # build request if not self._get_csw(): return # TODO: allow users to select resources types # to find ('service', 'dataset', etc.) try: self.catalog.getrecords2(constraints=self.constraints, maxrecords=self.maxrecords, esn='full') except ExceptionReport as err: QApplication.restoreOverrideCursor() QMessageBox.warning(self, self.tr('Search error'), self.tr('Search error: %s') % err) return except Exception as err: QApplication.restoreOverrideCursor() QMessageBox.warning(self, self.tr('Connection error'), self.tr('Connection error: %s') % err) return if self.catalog.results['matches'] == 0: QApplication.restoreOverrideCursor() self.lblResults.setText(self.tr('0 results')) return QApplication.restoreOverrideCursor() self.display_results() def display_results(self): """display search results""" self.treeRecords.clear() position = self.catalog.results['returned'] + self.startfrom msg = self.tr('Showing %d - %d of %n result(s)', 'number of results', self.catalog.results['matches']) % (self.startfrom + 1, position) self.lblResults.setText(msg) for rec in self.catalog.records: item = QTreeWidgetItem(self.treeRecords) if self.catalog.records[rec].type: item.setText(0, normalize_text(self.catalog.records[rec].type)) else: item.setText(0, 'unknown') if self.catalog.records[rec].title: item.setText(1, normalize_text(self.catalog.records[rec].title)) if self.catalog.records[rec].identifier: set_item_data(item, 'identifier', self.catalog.records[rec].identifier) self.btnShowXml.setEnabled(True) if self.catalog.results["matches"] < self.maxrecords: disabled = False else: disabled = True self.btnFirst.setEnabled(disabled) self.btnPrev.setEnabled(disabled) self.btnNext.setEnabled(disabled) self.btnLast.setEnabled(disabled) def record_clicked(self): """record clicked signal""" # disable only service buttons self.reset_buttons(True, False, False) if not self.treeRecords.selectedItems(): return item = self.treeRecords.currentItem() if not item: return identifier = get_item_data(item, 'identifier') try: record = self.catalog.records[identifier] except KeyError as err: QMessageBox.warning(self, self.tr('Record parsing error'), 'Unable to locate record identifier') return # if the record has a bbox, show a footprint on the map if record.bbox is not None: points = bbox_to_polygon(record.bbox) if points is not None: src = QgsCoordinateReferenceSystem(4326) dst = self.map.mapSettings().destinationCrs() geom = QgsGeometry.fromPolygon(points) if src.postgisSrid() != dst.postgisSrid(): ctr = QgsCoordinateTransform(src, dst) try: geom.transform(ctr) except Exception as err: QMessageBox.warning( self, self.tr('Coordinate Transformation Error'), unicode(err)) self.rubber_band.setToGeometry(geom, None) # figure out if the data is interactive and can be operated on self.find_services(record, item) def find_services(self, record, item): """scan record for WMS/WMTS|WFS|WCS endpoints""" links = record.uris + record.references services = {} for link in links: if 'scheme' in link: link_type = link['scheme'] elif 'protocol' in link: link_type = link['protocol'] else: link_type = None if link_type is not None: link_type = link_type.upper() wmswmst_link_types = map(str.upper, link_types.WMSWMST_LINK_TYPES) wfs_link_types = map(str.upper, link_types.WFS_LINK_TYPES) wcs_link_types = map(str.upper, link_types.WCS_LINK_TYPES) # if the link type exists, and it is one of the acceptable # interactive link types, then set if all([link_type is not None, link_type in wmswmst_link_types + wfs_link_types + wcs_link_types]): if link_type in wmswmst_link_types: services['wms'] = link['url'] self.btnAddToWms.setEnabled(True) if link_type in wfs_link_types: services['wfs'] = link['url'] self.btnAddToWfs.setEnabled(True) if link_type in wcs_link_types: services['wcs'] = link['url'] self.btnAddToWcs.setEnabled(True) set_item_data(item, 'link', json.dumps(services)) def navigate(self): """manage navigation / paging""" caller = self.sender().objectName() if caller == 'btnFirst': self.startfrom = 0 elif caller == 'btnLast': self.startfrom = self.catalog.results['matches'] - self.maxrecords elif caller == 'btnNext': self.startfrom += self.maxrecords if self.startfrom >= self.catalog.results["matches"]: msg = self.tr('End of results. Go to start?') res = QMessageBox.information(self, self.tr('Navigation'), msg, (QMessageBox.Ok | QMessageBox.Cancel)) if res == QMessageBox.Ok: self.startfrom = 0 else: return elif caller == "btnPrev": self.startfrom -= self.maxrecords if self.startfrom <= 0: msg = self.tr('Start of results. Go to end?') res = QMessageBox.information(self, self.tr('Navigation'), msg, (QMessageBox.Ok | QMessageBox.Cancel)) if res == QMessageBox.Ok: self.startfrom = (self.catalog.results['matches'] - self.maxrecords) else: return QApplication.setOverrideCursor(QCursor(Qt.WaitCursor)) try: self.catalog.getrecords2(constraints=self.constraints, maxrecords=self.maxrecords, startposition=self.startfrom, esn='full') except ExceptionReport as err: QApplication.restoreOverrideCursor() QMessageBox.warning(self, self.tr('Search error'), self.tr('Search error: %s') % err) return except Exception as err: QApplication.restoreOverrideCursor() QMessageBox.warning(self, self.tr('Connection error'), self.tr('Connection error: %s') % err) return QApplication.restoreOverrideCursor() self.display_results() def add_to_ows(self): """add to OWS provider connection list""" conn_name_matches = [] item = self.treeRecords.currentItem() if not item: return item_data = json.loads(get_item_data(item, 'link')) caller = self.sender().objectName() # stype = human name,/Qgis/connections-%s,providername if caller == 'btnAddToWms': stype = ['OGC:WMS/OGC:WMTS', 'wms', 'wms'] data_url = item_data['wms'] elif caller == 'btnAddToWfs': stype = ['OGC:WFS', 'wfs', 'WFS'] data_url = item_data['wfs'] elif caller == 'btnAddToWcs': stype = ['OGC:WCS', 'wcs', 'wcs'] data_url = item_data['wcs'] QApplication.restoreOverrideCursor() sname = '%s from MetaSearch' % stype[1] # store connection # check if there is a connection with same name self.settings.beginGroup('/Qgis/connections-%s' % stype[1]) keys = self.settings.childGroups() self.settings.endGroup() for key in keys: if key.startswith(sname): conn_name_matches.append(key) if conn_name_matches: sname = conn_name_matches[-1] # check for duplicates if sname in keys: # duplicate found if self.radioTitleAsk.isChecked(): # ask to overwrite msg = self.tr('Connection %s exists. Overwrite?') % sname res = QMessageBox.warning(self, self.tr('Saving server'), msg, QMessageBox.Yes | QMessageBox.No) if res != QMessageBox.Yes: # assign new name with serial sname = serialize_string(sname) elif self.radioTitleNoAsk.isChecked(): # don't ask to overwrite pass elif self.radioTempName.isChecked(): # use temp name sname = serialize_string(sname) # no dups detected or overwrite is allowed self.settings.beginGroup('/Qgis/connections-%s' % stype[1]) self.settings.setValue('/%s/url' % sname, data_url) self.settings.endGroup() # open provider window ows_provider = QgsProviderRegistry.instance().selectWidget(stype[2], self) service_type = stype[0] # connect dialog signals to iface slots if service_type == 'OGC:WMS/OGC:WMTS': ows_provider.addRasterLayer.connect(self.iface.addRasterLayer) conn_cmb = ows_provider.findChild(QWidget, 'cmbConnections') connect = 'on_btnConnect_clicked' elif service_type == 'OGC:WFS': ows_provider.addWfsLayer.connect(self.iface.mainWindow().addWfsLayer) conn_cmb = ows_provider.findChild(QWidget, 'cmbConnections') connect = 'connectToServer' elif service_type == 'OGC:WCS': ows_provider.addRasterLayer.connect(self.iface.addRasterLayer) conn_cmb = ows_provider.findChild(QWidget, 'mConnectionsComboBox') connect = 'on_mConnectButton_clicked' ows_provider.setModal(False) ows_provider.show() # open provider dialogue against added OWS index = conn_cmb.findText(sname) if index > -1: conn_cmb.setCurrentIndex(index) # only for wfs if service_type == 'OGC:WFS': ows_provider.on_cmbConnections_activated(index) getattr(ows_provider, connect)() def show_metadata(self): """show record metadata""" if not self.treeRecords.selectedItems(): return item = self.treeRecords.currentItem() if not item: return identifier = get_item_data(item, 'identifier') try: QApplication.setOverrideCursor(QCursor(Qt.WaitCursor)) cat = CatalogueServiceWeb(self.catalog_url, timeout=self.timeout) cat.getrecordbyid( [self.catalog.records[identifier].identifier]) except ExceptionReport as err: QApplication.restoreOverrideCursor() QMessageBox.warning(self, self.tr('GetRecords error'), self.tr('Error getting response: %s') % err) return except KeyError as err: QMessageBox.warning(self, self.tr('Record parsing error'), 'Unable to locate record identifier') QApplication.restoreOverrideCursor() return QApplication.restoreOverrideCursor() record = cat.records[identifier] record.xml_url = cat.request crd = RecordDialog() metadata = render_template('en', self.context, record, 'record_metadata_dc.html') style = QgsApplication.reportStyleSheet() crd.textMetadata.document().setDefaultStyleSheet(style) crd.textMetadata.setHtml(metadata) crd.exec_() def show_xml(self): """show XML request / response""" crd = XMLDialog() request_html = highlight_xml(self.context, self.catalog.request) response_html = highlight_xml(self.context, self.catalog.response) style = QgsApplication.reportStyleSheet() crd.txtbrXMLRequest.clear() crd.txtbrXMLResponse.clear() crd.txtbrXMLRequest.document().setDefaultStyleSheet(style) crd.txtbrXMLResponse.document().setDefaultStyleSheet(style) crd.txtbrXMLRequest.setHtml(request_html) crd.txtbrXMLResponse.setHtml(response_html) crd.exec_() def reset_buttons(self, services=True, xml=True, navigation=True): """Convenience function to disable WMS/WMTS|WFS|WCS buttons""" if services: self.btnAddToWms.setEnabled(False) self.btnAddToWfs.setEnabled(False) self.btnAddToWcs.setEnabled(False) if xml: self.btnShowXml.setEnabled(False) if navigation: self.btnFirst.setEnabled(False) self.btnPrev.setEnabled(False) self.btnNext.setEnabled(False) self.btnLast.setEnabled(False) def help(self): """launch help""" open_url(get_help_url()) def reject(self): """back out of dialogue""" QDialog.reject(self) self.rubber_band.reset() def _get_csw(self): """convenience function to init owslib.csw.CatalogueServiceWeb""" # connect to the server try: QApplication.setOverrideCursor(QCursor(Qt.WaitCursor)) self.catalog = CatalogueServiceWeb(self.catalog_url, timeout=self.timeout) return True except ExceptionReport as err: msg = self.tr('Error connecting to service: %s') % err except ValueError as err: msg = self.tr('Value Error: %s') % err except Exception as err: msg = self.tr('Unknown Error: %s') % err QMessageBox.warning(self, self.tr('CSW Connection error'), msg) QApplication.restoreOverrideCursor() return False def install_proxy(self): """set proxy if one is set in QGIS network settings""" # initially support HTTP for now if self.settings.value('/proxy/proxyEnabled') == 'true': if self.settings.value('/proxy/proxyType') == 'HttpProxy': ptype = 'http' else: return user = self.settings.value('/proxy/proxyUser') password = self.settings.value('/proxy/proxyPassword') host = self.settings.value('/proxy/proxyHost') port = self.settings.value('/proxy/proxyPort') proxy_up = '' proxy_port = '' if all([user != '', password != '']): proxy_up = '%s:%s@' % (user, password) if port != '': proxy_port = ':%s' % port conn = '%s://%s%s%s' % (ptype, proxy_up, host, proxy_port) install_opener(build_opener(ProxyHandler({ptype: conn})))
class ManageConnectionsDialog(QDialog, BASE_CLASS): """manage connections""" def __init__(self, mode): """init dialog""" QDialog.__init__(self) self.setupUi(self) self.settings = QSettings() self.filename = None self.mode = mode # 0 - save, 1 - load self.btnBrowse.clicked.connect(self.select_file) self.manage_gui() def manage_gui(self): """manage interface""" if self.mode == 1: self.label.setText(self.tr('Load from file')) self.buttonBox.button(QDialogButtonBox.Ok).setText(self.tr('Load')) else: self.label.setText(self.tr('Save to file')) self.buttonBox.button(QDialogButtonBox.Ok).setText(self.tr('Save')) self.populate() self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(False) def select_file(self): """select file ops""" label = self.tr('eXtensible Markup Language (*.xml *.XML)') if self.mode == 0: slabel = self.tr('Save connections') self.filename, filter = QFileDialog.getSaveFileName( self, slabel, '.', label) else: slabel = self.tr('Load connections') self.filename, selected_filter = QFileDialog.getOpenFileName( self, slabel, '.', label) if not self.filename: return # ensure the user never omitted the extension from the file name if not self.filename.lower().endswith('.xml'): self.filename = '%s.xml' % self.filename self.leFileName.setText(self.filename) if self.mode == 1: self.populate() self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(True) def populate(self): """populate connections list from settings""" if self.mode == 0: self.settings.beginGroup('/MetaSearch/') keys = self.settings.childGroups() for key in keys: item = QListWidgetItem(self.listConnections) item.setText(key) self.settings.endGroup() else: # populate connections list from file doc = get_connections_from_file(self, self.filename) if doc is None: self.filename = None self.leFileName.clear() self.listConnections.clear() return for csw in doc.findall('csw'): item = QListWidgetItem(self.listConnections) item.setText(csw.attrib.get('name')) def save(self, connections): """save connections ops""" doc = etree.Element('qgsCSWConnections') doc.attrib['version'] = '1.0' for conn in connections: url = self.settings.value('/MetaSearch/%s/url' % conn) if url is not None: connection = etree.SubElement(doc, 'csw') connection.attrib['name'] = conn connection.attrib['url'] = url # write to disk with open(self.filename, 'w') as fileobj: fileobj.write(prettify_xml(etree.tostring(doc))) QMessageBox.information(self, self.tr('Save Connections'), self.tr('Saved to %s') % self.filename) self.reject() def load(self, items): """load connections""" self.settings.beginGroup('/MetaSearch/') keys = self.settings.childGroups() self.settings.endGroup() exml = etree.parse(self.filename).getroot() for csw in exml.findall('csw'): conn_name = csw.attrib.get('name') # process only selected connections if conn_name not in items: continue # check for duplicates if conn_name in keys: label = self.tr('File %s exists. Overwrite?') % conn_name res = QMessageBox.warning(self, self.tr('Loading Connections'), label, QMessageBox.Yes | QMessageBox.No) if res != QMessageBox.Yes: continue # no dups detected or overwrite is allowed url = '/MetaSearch/%s/url' % conn_name self.settings.setValue(url, csw.attrib.get('url')) def accept(self): """accept connections""" selection = self.listConnections.selectedItems() if len(selection) == 0: return items = [] for sel in selection: items.append(sel.text()) if self.mode == 0: # save self.save(items) else: # load self.load(items) self.filename = None self.leFileName.clear() self.listConnections.clear() self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(False) def reject(self): """back out of manage connections dialogue""" QDialog.reject(self)
class ManageConnectionsDialog(QDialog, BASE_CLASS): """manage connections""" def __init__(self, mode): """init dialog""" QDialog.__init__(self) self.setupUi(self) self.settings = QSettings() self.filename = None self.mode = mode # 0 - save, 1 - load self.btnBrowse.clicked.connect(self.select_file) self.manage_gui() def manage_gui(self): """manage interface""" if self.mode == 1: self.label.setText(self.tr('Load from file')) self.buttonBox.button(QDialogButtonBox.Ok).setText(self.tr('Load')) else: self.label.setText(self.tr('Save to file')) self.buttonBox.button(QDialogButtonBox.Ok).setText(self.tr('Save')) self.populate() self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(False) def select_file(self): """select file ops""" label = self.tr('eXtensible Markup Language (*.xml *.XML)') if self.mode == 0: slabel = self.tr('Save connections') self.filename = QFileDialog.getSaveFileName(self, slabel, '.', label) else: slabel = self.tr('Load connections') self.filename = QFileDialog.getOpenFileName(self, slabel, '.', label) if not self.filename: return # ensure the user never omitted the extension from the file name if not self.filename.lower().endswith('.xml'): self.filename = '%s.xml' % self.filename self.leFileName.setText(self.filename) if self.mode == 1: self.populate() self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(True) def populate(self): """populate connections list from settings""" if self.mode == 0: self.settings.beginGroup('/MetaSearch/') keys = self.settings.childGroups() for key in keys: item = QListWidgetItem(self.listConnections) item.setText(key) self.settings.endGroup() else: # populate connections list from file doc = get_connections_from_file(self, self.filename) if doc is None: self.filename = None self.leFileName.clear() self.listConnections.clear() return for csw in doc.findall('csw'): item = QListWidgetItem(self.listConnections) item.setText(csw.attrib.get('name')) def save(self, connections): """save connections ops""" doc = etree.Element('qgsCSWConnections') doc.attrib['version'] = '1.0' for conn in connections: url = self.settings.value('/MetaSearch/%s/url' % conn) if url is not None: connection = etree.SubElement(doc, 'csw') connection.attrib['name'] = conn connection.attrib['url'] = url # write to disk with open(self.filename, 'w') as fileobj: fileobj.write(prettify_xml(etree.tostring(doc))) QMessageBox.information(self, self.tr('Save Connections'), self.tr('Saved to %s') % self.filename) self.reject() def load(self, items): """load connections""" self.settings.beginGroup('/MetaSearch/') keys = self.settings.childGroups() self.settings.endGroup() exml = etree.parse(self.filename).getroot() for csw in exml.findall('csw'): conn_name = csw.attrib.get('name') # process only selected connections if conn_name not in items: continue # check for duplicates if conn_name in keys: label = self.tr('File %s exists. Overwrite?') % conn_name res = QMessageBox.warning(self, self.tr('Loading Connections'), label, QMessageBox.Yes | QMessageBox.No) if res != QMessageBox.Yes: continue # no dups detected or overwrite is allowed url = '/MetaSearch/%s/url' % conn_name self.settings.setValue(url, csw.attrib.get('url')) def accept(self): """accept connections""" selection = self.listConnections.selectedItems() if len(selection) == 0: return items = [] for sel in selection: items.append(sel.text()) if self.mode == 0: # save self.save(items) else: # load self.load(items) self.filename = None self.leFileName.clear() self.listConnections.clear() self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(False) def reject(self): """back out of manage connections dialogue""" QDialog.reject(self)
def dbConnectionNames(self): settings = QSettings() settings.beginGroup('/PostgreSQL/connections/') return settings.childGroups()
def connChanged(self, conn_name='', schema_name=''): # close any existing connection to a river database if self.rdb: self.addInfo("Closing existing connection to {0}@{1} river database".format(self.rdb.dbname, self.rdb.host)) self.rdb.disconnect_pg() self.rdb = None else: pass s = QSettings() s.beginGroup('/PostgreSQL/connections') connsNames = s.childGroups() if conn_name in connsNames: self.curConnName = conn_name else: self.curConnName = self.ui.connsCbo.currentText() self.ui.connsCbo.clear() self.ui.connsCbo.addItem('') for conn in connsNames: self.ui.connsCbo.addItem(conn) try: i = connsNames.index(self.curConnName) + 1 except ValueError: i = 0 self.ui.connsCbo.setCurrentIndex(i) if self.ui.connsCbo.currentIndex() == 0: self.ui.schemasCbo.clear() self.ui.schemasCbo.addItem('') self.disableActions() return connName = self.ui.connsCbo.currentText() s.endGroup() s.beginGroup('/PostgreSQL/connections/{0}'.format(connName)) # first try to get the credentials from AuthManager, then from the basic settings authconf = s.value('authcfg', None) if authconf: auth_manager = QgsApplication.authManager() conf = QgsAuthMethodConfig() auth_manager.loadAuthenticationConfig(authconf, conf, True) if conf.id(): self.user = conf.config('username', '') self.passwd = conf.config('password', '') else: self.user = s.value('username') self.passwd = s.value('password') self.host = s.value('host') self.port = s.value('port') self.database = s.value('database') s.endGroup() # create a new connection to river database self.rdb = rivdb.RiverDatabase(self, self.database, self.host, self.port, self.user, self.passwd) self.rdb.SRID = int(self.crs.postgisSrid()) if self.rdb.connect_pg(): self.addInfo('Created connection to river database: {0}@{1}'.format(self.rdb.dbname, self.rdb.host)) self.rdb.last_conn = connName else: info = 'Couldn\'t connect to river database: {0}@{1}'.format(self.rdb.dbname, self.rdb.host) info += '\nPlease, check you database connection settings!' self.addInfo(info) self.ui.schemasCbo.clear() return # refresh schemas combo schemaName = self.ui.schemasCbo.currentText() qry = "SELECT nspname FROM pg_namespace WHERE nspname !~ '^pg_' AND nspname != 'information_schema' ORDER BY nspname" schemas = self.rdb.run_query(qry, fetch=True) self.ui.schemasCbo.clear() self.ui.schemasCbo.addItem('') if not schemas: schemas = [] for schema in schemas: self.ui.schemasCbo.addItem(schema[0]) if schema_name: schemaExists = self.ui.schemasCbo.findText(schema_name) else: schemaExists = self.ui.schemasCbo.findText(schemaName) if schemaExists: self.ui.schemasCbo.setCurrentIndex(schemaExists) self.enableDBActions() self.schemaChanged()
# -*- coding: utf-8 -*- from __future__ import (absolute_import, division, print_function, unicode_literals) # PyQT from qgis.PyQt.QtCore import QSettings # QGIS Qt Application settings qsettings = QSettings() # list subgroups print(qsettings.childGroups()) # get Isogeo settings qsettings.beginGroup("isogeo") print(qsettings.childGroups()) print(qsettings.allKeys()) # exit Isogeo settings qsettings.endGroup()
# -*- coding: utf-8 -*- """ A script to remove Isogeo's settings from QGIS' settings. Usefull to test first authentication to Isogeo plugin. """ from qgis.PyQt.QtCore import QSettings qsettings = QSettings() if "isogeo" in qsettings.childGroups(): print("'isogeo' child group detected in QSettings --> removing it") qsettings.remove("isogeo") else: print("QSettings already cleared")
def get_postgres_connections(): settings = QSettings() settings.beginGroup('/PostgreSQL/connections/') connections = settings.childGroups() settings.endGroup() return connections
# -*- coding: utf-8 -*- #! python3 # noqa: E265 # PyQT from qgis.PyQt.QtCore import QSettings # QGIS Qt Application settings qsettings = QSettings() # list subgroups print(qsettings.childGroups()) # get Isogeo settings qsettings.beginGroup("isogeo") print(qsettings.childGroups()) print(qsettings.allKeys()) # exit Isogeo settings qsettings.endGroup()