class HistoryDialog(QDialog, Ui_HistoryDialogPythonConsole):
def __init__(self, parent):
QDialog.__init__(self, parent)
self.setupUi(self)
self.parent = parent
self.setWindowTitle(
QCoreApplication.translate("PythonConsole",
"Python Console - Command History"))
self.listView.setToolTip(
QCoreApplication.translate("PythonConsole",
"Double-click on item to execute"))
self.model = QStandardItemModel(self.listView)
self._reloadHistory()
self.deleteScut = QShortcut(QKeySequence(Qt.Key_Delete), self)
self.deleteScut.activated.connect(self._deleteItem)
self.listView.doubleClicked.connect(self._runHistory)
self.reloadHistory.clicked.connect(self._reloadHistory)
self.saveHistory.clicked.connect(self._saveHistory)
def _runHistory(self, item):
cmd = item.data(Qt.DisplayRole)
self.parent.runCommand(cmd)
def _saveHistory(self):
self.parent.writeHistoryFile(True)
def _reloadHistory(self):
self.model.clear()
for i in self.parent.history:
item = QStandardItem(i)
if sys.platform.startswith('win'):
item.setSizeHint(QSize(18, 18))
self.model.appendRow(item)
self.listView.setModel(self.model)
self.listView.scrollToBottom()
def _deleteItem(self):
itemsSelected = self.listView.selectionModel().selectedIndexes()
if itemsSelected:
item = itemsSelected[0].row()
# Remove item from the command history (just for the current session)
self.parent.history.pop(item)
self.parent.softHistory.pop(item)
if item < self.parent.softHistoryIndex:
self.parent.softHistoryIndex -= 1
self.parent.setText(
self.parent.softHistory[self.parent.softHistoryIndex])
self.parent.move_cursor_to_end()
# Remove row from the command history dialog
self.model.removeRow(item)
class HistoryDialog(QDialog, Ui_HistoryDialogPythonConsole):
def __init__(self, parent):
QDialog.__init__(self, parent)
self.setupUi(self)
self.parent = parent
self.setWindowTitle(QCoreApplication.translate("PythonConsole",
"Python Console - Command History"))
self.listView.setToolTip(QCoreApplication.translate("PythonConsole",
"Double click on item to execute"))
self.model = QStandardItemModel(self.listView)
self._reloadHistory()
self.deleteScut = QShortcut(QKeySequence(Qt.Key_Delete), self)
self.deleteScut.activated.connect(self._deleteItem)
self.listView.doubleClicked.connect(self._runHistory)
self.reloadHistory.clicked.connect(self._reloadHistory)
self.saveHistory.clicked.connect(self._saveHistory)
def _runHistory(self, item):
cmd = item.data(Qt.DisplayRole)
self.parent.runCommand(cmd)
def _saveHistory(self):
self.parent.writeHistoryFile(True)
def _reloadHistory(self):
self.model.clear()
for i in self.parent.history:
item = QStandardItem(i)
if sys.platform.startswith('win'):
item.setSizeHint(QSize(18, 18))
self.model.appendRow(item)
self.listView.setModel(self.model)
self.listView.scrollToBottom()
def _deleteItem(self):
itemsSelected = self.listView.selectionModel().selectedIndexes()
if itemsSelected:
item = itemsSelected[0].row()
## Remove item from the command history (just for the current session)
self.parent.history.pop(item)
self.parent.historyIndex -= 1
## Remove row from the command history dialog
self.model.removeRow(item)
class StartWidget(uicls_start_page, basecls_start_page):
"""Widget for the Start page."""
def __init__(self, parent_page):
super().__init__()
self.setupUi(self)
self.parent_page = parent_page
self.tv_revisions_model = QStandardItemModel()
self.revisions_tv.setModel(self.tv_revisions_model)
self.current_local_schematisation = self.parent_page.parent_wizard.current_local_schematisation
self.schematisation = self.parent_page.parent_wizard.schematisation
self.schematisation_sqlite = self.parent_page.parent_wizard.schematisation_sqlite
self.available_revisions = self.parent_page.parent_wizard.available_revisions
self.latest_revision = self.parent_page.parent_wizard.latest_revision
organisation = self.parent_page.parent_wizard.plugin_dock.organisations[
self.schematisation.owner]
wip_revision = self.current_local_schematisation.wip_revision
self.lbl_schematisation.setText(
f"{self.schematisation.name} ({organisation.name})")
self.lbl_model_dir.setText(wip_revision.schematisation_dir)
self.lbl_revision_number.setText(str(wip_revision.number))
self.populate_available_revisions()
def populate_available_revisions(self):
self.tv_revisions_model.clear()
header = [
"Revision number", "Committed by", "Commit date", "Commit message"
]
self.tv_revisions_model.setHorizontalHeaderLabels(header)
for revision in sorted(self.available_revisions,
key=attrgetter("number"),
reverse=True):
number_item = QStandardItem(str(revision.number))
commit_user_item = QStandardItem(revision.commit_user or "")
commit_date = revision.commit_date.strftime(
"%d-%m-%Y") if revision.commit_date else ""
commit_date_item = QStandardItem(commit_date)
commit_message_item = QStandardItem(revision.commit_message or "")
self.tv_revisions_model.appendRow([
number_item, commit_user_item, commit_date_item,
commit_message_item
])
for i in range(len(header)):
self.revisions_tv.resizeColumnToContents(i)
class ConfigDialog(BASE, WIDGET):
def __init__(self, showSearch=True):
super(ConfigDialog, self).__init__(None)
self.setupUi(self)
self.groupIcon = QIcon()
self.groupIcon.addPixmap(self.style().standardPixmap(
QStyle.SP_DirClosedIcon), QIcon.Normal, QIcon.Off)
self.groupIcon.addPixmap(self.style().standardPixmap(
QStyle.SP_DirOpenIcon), QIcon.Normal, QIcon.On)
self.model = QStandardItemModel()
self.tree.setModel(self.model)
self.delegate = SettingDelegate()
self.tree.setItemDelegateForColumn(1, self.delegate)
if showSearch:
if hasattr(self.searchBox, 'setPlaceholderText'):
self.searchBox.setPlaceholderText(QApplication.translate('ConfigDialog', 'Search…'))
self.searchBox.textChanged.connect(self.textChanged)
else:
self.searchBox.hide()
self.fillTree()
self.saveMenus = False
self.tree.expanded.connect(self.itemExpanded)
self.auto_adjust_columns = True
def textChanged(self, text=None):
if text is not None:
text = str(text.lower())
else:
text = str(self.searchBox.text().lower())
found = self._filterItem(self.model.invisibleRootItem(), text)
self.auto_adjust_columns = False
if text:
self.tree.expandAll()
else:
self.tree.collapseAll()
self.adjustColumns()
self.auto_adjust_columns = True
if text:
return found
else:
self.tree.collapseAll()
return False
def _filterItem(self, item, text, forceShow=False):
if item.hasChildren():
show = forceShow or isinstance(item, QStandardItem) and bool(text) and (text in item.text().lower())
for i in range(item.rowCount()):
child = item.child(i)
show = self._filterItem(child, text, forceShow) or show
self.tree.setRowHidden(item.row(), item.index().parent(), not show)
return show
elif isinstance(item, QStandardItem):
show = forceShow or bool(text) and (text in item.text().lower())
self.tree.setRowHidden(item.row(), item.index().parent(), not show)
return show
def fillTree(self):
self.fillTreeUsingProviders()
def fillTreeUsingProviders(self):
self.items = {}
self.model.clear()
self.model.setHorizontalHeaderLabels([self.tr('Setting'),
self.tr('Value')])
settings = ProcessingConfig.getSettings()
rootItem = self.model.invisibleRootItem()
"""
Filter 'General', 'Models' and 'Scripts' items
"""
priorityKeys = [self.tr('General'), self.tr('Models'), self.tr('Scripts')]
for group in priorityKeys:
groupItem = QStandardItem(group)
icon = ProcessingConfig.getGroupIcon(group)
groupItem.setIcon(icon)
groupItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [groupItem, emptyItem])
if not group in settings:
continue
# add menu item only if it has any search matches
for setting in settings[group]:
if setting.hidden or setting.name.startswith("MENU_"):
continue
labelItem = QStandardItem(setting.description)
labelItem.setIcon(icon)
labelItem.setEditable(False)
self.items[setting] = SettingItem(setting)
groupItem.insertRow(0, [labelItem, self.items[setting]])
"""
Filter 'Providers' items
"""
providersItem = QStandardItem(self.tr('Providers'))
icon = QgsApplication.getThemeIcon("/processingAlgorithm.svg")
providersItem.setIcon(icon)
providersItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [providersItem, emptyItem])
for group in list(settings.keys()):
if group in priorityKeys or group == menusSettingsGroup:
continue
groupItem = QStandardItem(group)
icon = ProcessingConfig.getGroupIcon(group)
groupItem.setIcon(icon)
groupItem.setEditable(False)
for setting in settings[group]:
if setting.hidden:
continue
labelItem = QStandardItem(setting.description)
labelItem.setIcon(icon)
labelItem.setEditable(False)
self.items[setting] = SettingItem(setting)
groupItem.insertRow(0, [labelItem, self.items[setting]])
emptyItem = QStandardItem()
emptyItem.setEditable(False)
providersItem.appendRow([groupItem, emptyItem])
"""
Filter 'Menus' items
"""
self.menusItem = QStandardItem(self.tr('Menus'))
icon = QIcon(os.path.join(pluginPath, 'images', 'menu.png'))
self.menusItem.setIcon(icon)
self.menusItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [self.menusItem, emptyItem])
button = QPushButton(self.tr('Reset to defaults'))
button.clicked.connect(self.resetMenusToDefaults)
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(button)
layout.addStretch()
widget = QWidget()
widget.setLayout(layout)
self.tree.setIndexWidget(emptyItem.index(), widget)
for provider in QgsApplication.processingRegistry().providers():
providerDescription = provider.name()
groupItem = QStandardItem(providerDescription)
icon = provider.icon()
groupItem.setIcon(icon)
groupItem.setEditable(False)
for alg in provider.algorithms():
algItem = QStandardItem(alg.displayName())
algItem.setIcon(icon)
algItem.setEditable(False)
try:
settingMenu = ProcessingConfig.settings["MENU_" + alg.id()]
settingButton = ProcessingConfig.settings["BUTTON_" + alg.id()]
settingIcon = ProcessingConfig.settings["ICON_" + alg.id()]
except:
continue
self.items[settingMenu] = SettingItem(settingMenu)
self.items[settingButton] = SettingItem(settingButton)
self.items[settingIcon] = SettingItem(settingIcon)
menuLabelItem = QStandardItem("Menu path")
menuLabelItem.setEditable(False)
buttonLabelItem = QStandardItem("Add button in toolbar")
buttonLabelItem.setEditable(False)
iconLabelItem = QStandardItem("Icon")
iconLabelItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
algItem.insertRow(0, [menuLabelItem, self.items[settingMenu]])
algItem.insertRow(0, [buttonLabelItem, self.items[settingButton]])
algItem.insertRow(0, [iconLabelItem, self.items[settingIcon]])
groupItem.insertRow(0, [algItem, emptyItem])
emptyItem = QStandardItem()
emptyItem.setEditable(False)
self.menusItem.appendRow([groupItem, emptyItem])
self.tree.sortByColumn(0, Qt.AscendingOrder)
self.adjustColumns()
def resetMenusToDefaults(self):
for provider in QgsApplication.processingRegistry().providers():
for alg in provider.algorithms():
d = defaultMenuEntries.get(alg.id(), "")
setting = ProcessingConfig.settings["MENU_" + alg.id()]
item = self.items[setting]
item.setData(d, Qt.EditRole)
self.saveMenus = True
def accept(self):
qsettings = QgsSettings()
for setting in list(self.items.keys()):
if setting.group != menusSettingsGroup or self.saveMenus:
if isinstance(setting.value, bool):
setting.setValue(self.items[setting].checkState() == Qt.Checked)
else:
try:
setting.setValue(str(self.items[setting].text()))
except ValueError as e:
QMessageBox.warning(self, self.tr('Wrong value'),
self.tr('Wrong value for parameter "{0}":\n\n{1}').format(setting.description, str(e)))
return
setting.save(qsettings)
with OverrideCursor(Qt.WaitCursor):
for p in QgsApplication.processingRegistry().providers():
p.refreshAlgorithms()
settingsWatcher.settingsChanged.emit()
def itemExpanded(self, idx):
if idx == self.menusItem.index():
self.saveMenus = True
if self.auto_adjust_columns:
self.adjustColumns()
def adjustColumns(self):
self.tree.resizeColumnToContents(0)
self.tree.resizeColumnToContents(1)
class DlgSqlLayerWindow(QWidget, Ui_Dialog):
nameChanged = pyqtSignal(str)
def __init__(self, iface, layer, parent=None):
QWidget.__init__(self, parent)
self.iface = iface
self.layer = layer
uri = QgsDataSourceUri(layer.source())
dbplugin = None
db = None
if layer.dataProvider().name() == 'postgres':
dbplugin = createDbPlugin('postgis', 'postgres')
elif layer.dataProvider().name() == 'spatialite':
dbplugin = createDbPlugin('spatialite', 'spatialite')
elif layer.dataProvider().name() == 'oracle':
dbplugin = createDbPlugin('oracle', 'oracle')
elif layer.dataProvider().name() == 'virtual':
dbplugin = createDbPlugin('vlayers', 'virtual')
elif layer.dataProvider().name() == 'ogr':
dbplugin = createDbPlugin('gpkg', 'gpkg')
if dbplugin:
dbplugin.connectToUri(uri)
db = dbplugin.db
self.dbplugin = dbplugin
self.db = db
self.filter = ""
self.allowMultiColumnPk = isinstance(
db, PGDatabase
) # at the moment only PostgreSQL allows a primary key to span multiple columns, SpatiaLite doesn't
self.aliasSubQuery = isinstance(
db,
PGDatabase) # only PostgreSQL requires subqueries to be aliases
self.setupUi(self)
self.setWindowTitle(
u"%s - %s [%s]" %
(self.windowTitle(), db.connection().connectionName(),
db.connection().typeNameString()))
self.defaultLayerName = 'QueryLayer'
if self.allowMultiColumnPk:
self.uniqueColumnCheck.setText(
self.tr("Column(s) with unique values"))
else:
self.uniqueColumnCheck.setText(
self.tr("Column with unique values"))
self.editSql.setFocus()
self.editSql.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.editSql.setMarginVisible(True)
self.initCompleter()
# allow copying results
copyAction = QAction("copy", self)
self.viewResult.addAction(copyAction)
copyAction.setShortcuts(QKeySequence.Copy)
copyAction.triggered.connect(self.copySelectedResults)
self.btnExecute.clicked.connect(self.executeSql)
self.btnSetFilter.clicked.connect(self.setFilter)
self.btnClear.clicked.connect(self.clearSql)
self.presetStore.clicked.connect(self.storePreset)
self.presetDelete.clicked.connect(self.deletePreset)
self.presetCombo.activated[str].connect(self.loadPreset)
self.presetCombo.activated[str].connect(self.presetName.setText)
self.editSql.textChanged.connect(self.updatePresetButtonsState)
self.presetName.textChanged.connect(self.updatePresetButtonsState)
self.presetCombo.currentIndexChanged.connect(
self.updatePresetButtonsState)
self.updatePresetsCombobox()
self.geomCombo.setEditable(True)
self.geomCombo.lineEdit().setReadOnly(True)
self.uniqueCombo.setEditable(True)
self.uniqueCombo.lineEdit().setReadOnly(True)
self.uniqueModel = QStandardItemModel(self.uniqueCombo)
self.uniqueCombo.setModel(self.uniqueModel)
if self.allowMultiColumnPk:
self.uniqueCombo.setItemDelegate(QStyledItemDelegate())
self.uniqueModel.itemChanged.connect(
self.uniqueChanged) # react to the (un)checking of an item
self.uniqueCombo.lineEdit().textChanged.connect(
self.uniqueTextChanged
) # there are other events that change the displayed text and some of them can not be caught directly
self.layerTypeWidget.hide() # show if load as raster is supported
# self.loadLayerBtn.clicked.connect(self.loadSqlLayer)
self.updateLayerBtn.clicked.connect(self.updateSqlLayer)
self.getColumnsBtn.clicked.connect(self.fillColumnCombos)
self.queryBuilderFirst = True
self.queryBuilderBtn.setIcon(QIcon(":/db_manager/icons/sql.gif"))
self.queryBuilderBtn.clicked.connect(self.displayQueryBuilder)
self.presetName.textChanged.connect(self.nameChanged)
# Update from layer
# First the SQL from QgsDataSourceUri table
sql = uri.table()
if uri.keyColumn() == '_uid_':
match = re.search(
r'^\(SELECT .+ AS _uid_,\* FROM \((.*)\) AS _subq_.+_\s*\)$',
sql, re.S | re.X)
if match:
sql = match.group(1)
else:
match = re.search(r'^\((SELECT .+ FROM .+)\)$', sql, re.S | re.X)
if match:
sql = match.group(1)
# Need to check on table() since the parentheses were removed by the regexp
if not uri.table().startswith('(') and not uri.table().endswith(')'):
schema = uri.schema()
if schema and schema.upper() != 'PUBLIC':
sql = 'SELECT * FROM {0}.{1}'.format(
self.db.connector.quoteId(schema),
self.db.connector.quoteId(sql))
else:
sql = 'SELECT * FROM {0}'.format(
self.db.connector.quoteId(sql))
self.editSql.setText(sql)
self.executeSql()
# Then the columns
self.geomCombo.setCurrentIndex(
self.geomCombo.findText(uri.geometryColumn(), Qt.MatchExactly))
if uri.keyColumn() != '_uid_':
self.uniqueColumnCheck.setCheckState(Qt.Checked)
if self.allowMultiColumnPk:
itemsData = uri.keyColumn().split(',')
for item in self.uniqueModel.findItems("*", Qt.MatchWildcard):
if item.data() in itemsData:
item.setCheckState(Qt.Checked)
else:
keyColumn = uri.keyColumn()
for item in self.uniqueModel.findItems("*", Qt.MatchWildcard):
if item.data() == keyColumn:
self.uniqueCombo.setCurrentIndex(
self.uniqueModel.indexFromItem(item).row())
# Finally layer name, filter and selectAtId
self.layerNameEdit.setText(layer.name())
self.filter = uri.sql()
if uri.selectAtIdDisabled():
self.avoidSelectById.setCheckState(Qt.Checked)
def getQueryHash(self, name):
return 'q%s' % md5(name.encode('utf8')).hexdigest()
def updatePresetButtonsState(self, *args):
"""Slot called when the combo box or the sql or the query name have changed:
sets store button state"""
self.presetStore.setEnabled(
bool(self._getSqlQuery() and self.presetName.text()))
self.presetDelete.setEnabled(
bool(self.presetCombo.currentIndex() != -1))
def updatePresetsCombobox(self):
self.presetCombo.clear()
names = []
entries = QgsProject.instance().subkeyList('DBManager', 'savedQueries')
for entry in entries:
name = QgsProject.instance().readEntry(
'DBManager', 'savedQueries/' + entry + '/name')[0]
names.append(name)
for name in sorted(names):
self.presetCombo.addItem(name)
self.presetCombo.setCurrentIndex(-1)
def storePreset(self):
query = self._getSqlQuery()
if query == "":
return
name = self.presetName.text()
QgsProject.instance().writeEntry(
'DBManager', 'savedQueries/' + self.getQueryHash(name) + '/name',
name)
QgsProject.instance().writeEntry(
'DBManager', 'savedQueries/' + self.getQueryHash(name) + '/query',
query)
index = self.presetCombo.findText(name)
if index == -1:
self.presetCombo.addItem(name)
self.presetCombo.setCurrentIndex(self.presetCombo.count() - 1)
else:
self.presetCombo.setCurrentIndex(index)
def deletePreset(self):
name = self.presetCombo.currentText()
QgsProject.instance().removeEntry(
'DBManager', 'savedQueries/q' + self.getQueryHash(name))
self.presetCombo.removeItem(self.presetCombo.findText(name))
self.presetCombo.setCurrentIndex(-1)
def loadPreset(self, name):
query = QgsProject.instance().readEntry(
'DBManager',
'savedQueries/' + self.getQueryHash(name) + '/query')[0]
name = QgsProject.instance().readEntry(
'DBManager',
'savedQueries/' + self.getQueryHash(name) + '/name')[0]
self.editSql.setText(query)
def clearSql(self):
self.editSql.clear()
self.editSql.setFocus()
self.filter = ""
def executeSql(self):
sql = self._getSqlQuery()
if sql == "":
return
with OverrideCursor(Qt.WaitCursor):
# delete the old model
old_model = self.viewResult.model()
self.viewResult.setModel(None)
if old_model:
old_model.deleteLater()
cols = []
quotedCols = []
try:
# set the new model
model = self.db.sqlResultModel(sql, self)
self.viewResult.setModel(model)
self.lblResult.setText(
self.tr("{0} rows, {1:.1f} seconds").format(
model.affectedRows(), model.secs()))
cols = self.viewResult.model().columnNames()
for col in cols:
quotedCols.append(self.db.connector.quoteId(col))
except BaseError as e:
DlgDbError.showError(e, self)
self.uniqueModel.clear()
self.geomCombo.clear()
return
self.setColumnCombos(cols, quotedCols)
self.update()
def _getSqlLayer(self, _filter):
hasUniqueField = self.uniqueColumnCheck.checkState() == Qt.Checked
if hasUniqueField:
if self.allowMultiColumnPk:
checkedCols = []
for item in self.uniqueModel.findItems("*", Qt.MatchWildcard):
if item.checkState() == Qt.Checked:
checkedCols.append(item.data())
uniqueFieldName = ",".join(checkedCols)
elif self.uniqueCombo.currentIndex() >= 0:
uniqueFieldName = self.uniqueModel.item(
self.uniqueCombo.currentIndex()).data()
else:
uniqueFieldName = None
else:
uniqueFieldName = None
hasGeomCol = self.hasGeometryCol.checkState() == Qt.Checked
if hasGeomCol:
geomFieldName = self.geomCombo.currentText()
else:
geomFieldName = None
query = self._getSqlQuery()
if query == "":
return None
# remove a trailing ';' from query if present
if query.strip().endswith(';'):
query = query.strip()[:-1]
from qgis.core import QgsMapLayer
layerType = QgsMapLayer.VectorLayer if self.vectorRadio.isChecked(
) else QgsMapLayer.RasterLayer
# get a new layer name
names = []
for layer in list(QgsProject.instance().mapLayers().values()):
names.append(layer.name())
layerName = self.layerNameEdit.text()
if layerName == "":
layerName = self.defaultLayerName
newLayerName = layerName
index = 1
while newLayerName in names:
index += 1
newLayerName = u"%s_%d" % (layerName, index)
# create the layer
layer = self.db.toSqlLayer(query, geomFieldName, uniqueFieldName,
newLayerName, layerType,
self.avoidSelectById.isChecked(), _filter)
if layer.isValid():
return layer
else:
return None
def loadSqlLayer(self):
with OverrideCursor(Qt.WaitCursor):
layer = self._getSqlLayer(self.filter)
if layer is None:
return
QgsProject.instance().addMapLayers([layer], True)
def updateSqlLayer(self):
with OverrideCursor(Qt.WaitCursor):
layer = self._getSqlLayer(self.filter)
if layer is None:
return
# self.layer.dataProvider().setDataSourceUri(layer.dataProvider().dataSourceUri())
# self.layer.dataProvider().reloadData()
XMLDocument = QDomDocument("style")
XMLMapLayers = XMLDocument.createElement("maplayers")
XMLMapLayer = XMLDocument.createElement("maplayer")
self.layer.writeLayerXml(XMLMapLayer, XMLDocument,
QgsReadWriteContext())
XMLMapLayer.firstChildElement(
"datasource").firstChild().setNodeValue(layer.source())
XMLMapLayers.appendChild(XMLMapLayer)
XMLDocument.appendChild(XMLMapLayers)
self.layer.readLayerXml(XMLMapLayer, QgsReadWriteContext())
self.layer.reload()
self.iface.actionDraw().trigger()
self.iface.mapCanvas().refresh()
def fillColumnCombos(self):
query = self._getSqlQuery()
if query == "":
return
with OverrideCursor(Qt.WaitCursor):
# remove a trailing ';' from query if present
if query.strip().endswith(';'):
query = query.strip()[:-1]
# get all the columns
cols = []
quotedCols = []
connector = self.db.connector
if self.aliasSubQuery:
# get a new alias
aliasIndex = 0
while True:
alias = "_subQuery__%d" % aliasIndex
escaped = re.compile('\\b("?)' + re.escape(alias) +
'\\1\\b')
if not escaped.search(query):
break
aliasIndex += 1
sql = u"SELECT * FROM (%s\n) AS %s LIMIT 0" % (
str(query), connector.quoteId(alias))
else:
sql = u"SELECT * FROM (%s\n) WHERE 1=0" % str(query)
c = None
try:
c = connector._execute(None, sql)
cols = connector._get_cursor_columns(c)
for col in cols:
quotedCols.append(connector.quoteId(col))
except BaseError as e:
DlgDbError.showError(e, self)
self.uniqueModel.clear()
self.geomCombo.clear()
return
finally:
if c:
c.close()
del c
self.setColumnCombos(cols, quotedCols)
def setColumnCombos(self, cols, quotedCols):
# get sensible default columns. do this before sorting in case there's hints in the column order (e.g., id is more likely to be first)
try:
defaultGeomCol = next(
col for col in cols
if col in ['geom', 'geometry', 'the_geom', 'way'])
except:
defaultGeomCol = None
try:
defaultUniqueCol = [col for col in cols if 'id' in col][0]
except:
defaultUniqueCol = None
colNames = sorted(zip(cols, quotedCols))
newItems = []
uniqueIsFilled = False
for (col, quotedCol) in colNames:
item = QStandardItem(col)
item.setData(quotedCol)
item.setEnabled(True)
item.setCheckable(self.allowMultiColumnPk)
item.setSelectable(not self.allowMultiColumnPk)
if self.allowMultiColumnPk:
matchingItems = self.uniqueModel.findItems(col)
if matchingItems:
item.setCheckState(matchingItems[0].checkState())
uniqueIsFilled = uniqueIsFilled or matchingItems[
0].checkState() == Qt.Checked
else:
item.setCheckState(Qt.Unchecked)
newItems.append(item)
if self.allowMultiColumnPk:
self.uniqueModel.clear()
self.uniqueModel.appendColumn(newItems)
self.uniqueChanged()
else:
previousUniqueColumn = self.uniqueCombo.currentText()
self.uniqueModel.clear()
self.uniqueModel.appendColumn(newItems)
if self.uniqueModel.findItems(previousUniqueColumn):
self.uniqueCombo.setEditText(previousUniqueColumn)
uniqueIsFilled = True
oldGeometryColumn = self.geomCombo.currentText()
self.geomCombo.clear()
self.geomCombo.addItems(cols)
self.geomCombo.setCurrentIndex(
self.geomCombo.findText(oldGeometryColumn, Qt.MatchExactly))
# set sensible default columns if the columns are not already set
try:
if self.geomCombo.currentIndex() == -1:
self.geomCombo.setCurrentIndex(cols.index(defaultGeomCol))
except:
pass
items = self.uniqueModel.findItems(defaultUniqueCol)
if items and not uniqueIsFilled:
if self.allowMultiColumnPk:
items[0].setCheckState(Qt.Checked)
else:
self.uniqueCombo.setEditText(defaultUniqueCol)
try:
pass
except:
pass
def copySelectedResults(self):
if len(self.viewResult.selectedIndexes()) <= 0:
return
model = self.viewResult.model()
# convert to string using tab as separator
text = model.headerToString("\t")
for idx in self.viewResult.selectionModel().selectedRows():
text += "\n" + model.rowToString(idx.row(), "\t")
QApplication.clipboard().setText(text, QClipboard.Selection)
QApplication.clipboard().setText(text, QClipboard.Clipboard)
def initCompleter(self):
dictionary = None
if self.db:
dictionary = self.db.connector.getSqlDictionary()
if not dictionary:
# use the generic sql dictionary
from .sql_dictionary import getSqlDictionary
dictionary = getSqlDictionary()
wordlist = []
for name, value in dictionary.items():
wordlist += value # concat lists
wordlist = list(set(wordlist)) # remove duplicates
api = QsciAPIs(self.editSql.lexer())
for word in wordlist:
api.add(word)
api.prepare()
self.editSql.lexer().setAPIs(api)
def displayQueryBuilder(self):
dlg = QueryBuilderDlg(self.iface,
self.db,
self,
reset=self.queryBuilderFirst)
self.queryBuilderFirst = False
r = dlg.exec_()
if r == QDialog.Accepted:
self.editSql.setText(dlg.query)
def _getSqlQuery(self):
sql = self.editSql.selectedText()
if len(sql) == 0:
sql = self.editSql.text()
return sql
def uniqueChanged(self):
# when an item is (un)checked, simply trigger an update of the combobox text
self.uniqueTextChanged(None)
def uniqueTextChanged(self, text):
# Whenever there is new text displayed in the combobox, check if it is the correct one and if not, display the correct one.
checkedItems = []
for item in self.uniqueModel.findItems("*", Qt.MatchWildcard):
if item.checkState() == Qt.Checked:
checkedItems.append(item.text())
label = ", ".join(checkedItems)
if text != label:
self.uniqueCombo.setEditText(label)
def setFilter(self):
from qgis.gui import QgsQueryBuilder
layer = self._getSqlLayer("")
if not layer:
return
dlg = QgsQueryBuilder(layer)
dlg.setSql(self.filter)
if dlg.exec_():
self.filter = dlg.sql()
layer.deleteLater()
class ConfigDialog(BASE, WIDGET):
def __init__(self, toolbox):
super(ConfigDialog, self).__init__(None)
self.setupUi(self)
self.toolbox = toolbox
self.groupIcon = QIcon()
self.groupIcon.addPixmap(self.style().standardPixmap(
QStyle.SP_DirClosedIcon), QIcon.Normal, QIcon.Off)
self.groupIcon.addPixmap(self.style().standardPixmap(
QStyle.SP_DirOpenIcon), QIcon.Normal, QIcon.On)
if hasattr(self.searchBox, 'setPlaceholderText'):
self.searchBox.setPlaceholderText(self.tr('Search...'))
self.model = QStandardItemModel()
self.tree.setModel(self.model)
self.delegate = SettingDelegate()
self.tree.setItemDelegateForColumn(1, self.delegate)
self.searchBox.textChanged.connect(self.textChanged)
self.fillTree()
self.tree.expanded.connect(self.adjustColumns)
def textChanged(self):
text = str(self.searchBox.text().lower())
self._filterItem(self.model.invisibleRootItem(), text)
if text:
self.tree.expandAll()
else:
self.tree.collapseAll()
def _filterItem(self, item, text):
if item.hasChildren():
show = False
for i in range(item.rowCount()):
child = item.child(i)
showChild = self._filterItem(child, text)
show = (showChild or show)
self.tree.setRowHidden(item.row(), item.index().parent(), not show)
return show
elif isinstance(item, QStandardItem):
hide = bool(text) and (text not in item.text().lower())
self.tree.setRowHidden(item.row(), item.index().parent(), hide)
return not hide
def fillTree(self):
self.fillTreeUsingProviders()
def fillTreeUsingProviders(self):
self.items = {}
self.model.clear()
self.model.setHorizontalHeaderLabels([self.tr('Setting'),
self.tr('Value')])
settings = ProcessingConfig.getSettings()
rootItem = self.model.invisibleRootItem()
"""
Filter 'General', 'Models' and 'Scripts' items
"""
priorityKeys = [self.tr('General'), self.tr('Models'), self.tr('Scripts')]
for group in priorityKeys:
groupItem = QStandardItem(group)
icon = ProcessingConfig.getGroupIcon(group)
groupItem.setIcon(icon)
groupItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [groupItem, emptyItem])
# add menu item only if it has any search matches
for setting in settings[group]:
if setting.hidden or setting.name.startswith("MENU_"):
continue
labelItem = QStandardItem(setting.description)
labelItem.setIcon(icon)
labelItem.setEditable(False)
self.items[setting] = SettingItem(setting)
groupItem.insertRow(0, [labelItem, self.items[setting]])
"""
Filter 'Providers' items
"""
providersItem = QStandardItem(self.tr('Providers'))
icon = QIcon(os.path.join(pluginPath, 'images', 'alg.png'))
providersItem.setIcon(icon)
providersItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [providersItem, emptyItem])
for group in list(settings.keys()):
if group in priorityKeys or group == menusSettingsGroup:
continue
groupItem = QStandardItem(group)
icon = ProcessingConfig.getGroupIcon(group)
groupItem.setIcon(icon)
groupItem.setEditable(False)
for setting in settings[group]:
if setting.hidden:
continue
labelItem = QStandardItem(setting.description)
labelItem.setIcon(icon)
labelItem.setEditable(False)
self.items[setting] = SettingItem(setting)
groupItem.insertRow(0, [labelItem, self.items[setting]])
emptyItem = QStandardItem()
emptyItem.setEditable(False)
providersItem.appendRow([groupItem, emptyItem])
"""
Filter 'Menus' items
"""
menusItem = QStandardItem(self.tr('Menus'))
icon = QIcon(os.path.join(pluginPath, 'images', 'menu.png'))
menusItem.setIcon(icon)
menusItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [menusItem, emptyItem])
button = QPushButton(self.tr('Reset to defaults'))
button.clicked.connect(self.resetMenusToDefaults)
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(button)
layout.addStretch()
widget = QWidget()
widget.setLayout(layout)
self.tree.setIndexWidget(emptyItem.index(), widget)
providers = Processing.providers
for provider in providers:
providerDescription = provider.getDescription()
groupItem = QStandardItem(providerDescription)
icon = provider.getIcon()
groupItem.setIcon(icon)
groupItem.setEditable(False)
for alg in provider.algs:
algItem = QStandardItem(alg.i18n_name or alg.name)
algItem.setIcon(icon)
algItem.setEditable(False)
try:
settingMenu = ProcessingConfig.settings["MENU_" + alg.commandLineName()]
settingButton = ProcessingConfig.settings["BUTTON_" + alg.commandLineName()]
settingIcon = ProcessingConfig.settings["ICON_" + alg.commandLineName()]
except:
continue
self.items[settingMenu] = SettingItem(settingMenu)
self.items[settingButton] = SettingItem(settingButton)
self.items[settingIcon] = SettingItem(settingIcon)
menuLabelItem = QStandardItem("Menu path")
menuLabelItem.setEditable(False)
buttonLabelItem = QStandardItem("Add button in toolbar")
buttonLabelItem.setEditable(False)
iconLabelItem = QStandardItem("Icon")
iconLabelItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
algItem.insertRow(0, [menuLabelItem, self.items[settingMenu]])
algItem.insertRow(0, [buttonLabelItem, self.items[settingButton]])
algItem.insertRow(0, [iconLabelItem, self.items[settingIcon]])
groupItem.insertRow(0, [algItem, emptyItem])
emptyItem = QStandardItem()
emptyItem.setEditable(False)
menusItem.appendRow([groupItem, emptyItem])
self.tree.sortByColumn(0, Qt.AscendingOrder)
self.adjustColumns()
def resetMenusToDefaults(self):
providers = Processing.providers
for provider in providers:
for alg in provider.algs:
d = defaultMenuEntries.get(alg.commandLineName(), "")
setting = ProcessingConfig.settings["MENU_" + alg.commandLineName()]
item = self.items[setting]
item.setData(d, Qt.EditRole)
def accept(self):
for setting in list(self.items.keys()):
if isinstance(setting.value, bool):
setting.setValue(self.items[setting].checkState() == Qt.Checked)
else:
try:
setting.setValue(str(self.items[setting].text()))
except ValueError as e:
QMessageBox.warning(self, self.tr('Wrong value'),
self.tr('Wrong value for parameter "%s":\n\n%s' % (setting.description, str(e))))
return
setting.save()
Processing.updateAlgsList()
settingsWatcher.settingsChanged.emit()
QDialog.accept(self)
def adjustColumns(self):
self.tree.resizeColumnToContents(0)
self.tree.resizeColumnToContents(1)
class ResourceSharingDialog(QDialog, FORM_CLASS):
TAB_ALL = 0
TAB_INSTALLED = 1
TAB_SETTINGS = 2
def __init__(self, parent=None, iface=None):
"""Constructor.
:param parent: Optional widget to use as parent
:type parent: QWidget
:param iface: An instance of QGisInterface
:type iface: QGisInterface
"""
super(ResourceSharingDialog, self).__init__(parent)
self.setupUi(self)
self.iface = iface
# Reconfigure UI
self.setModal(True)
self.button_edit.setEnabled(False)
self.button_delete.setEnabled(False)
self.button_install.setEnabled(False)
self.button_open.setEnabled(False)
self.button_uninstall.setEnabled(False)
# Set up the "main menu" - QListWidgetItem
# All collections
icon_all = QIcon()
icon_all.addFile(str(resources_path('img', 'plugin.svg')), QSize(),
QIcon.Normal, QIcon.Off)
item_all = QListWidgetItem()
item_all.setIcon(icon_all)
item_all.setText(self.tr('All collections'))
# Installed collections
icon_installed = QIcon()
icon_installed.addFile(
str(resources_path('img', 'plugin-installed.svg')), QSize(),
QIcon.Normal, QIcon.Off)
item_installed = QListWidgetItem()
item_installed.setIcon(icon_installed)
item_installed.setText(self.tr('Installed collections'))
item_all.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
# Settings / repositories
icon_settings = QIcon()
icon_settings.addFile(str(resources_path('img', 'settings.svg')),
QSize(), QIcon.Normal, QIcon.Off)
item_settings = QListWidgetItem()
item_settings.setIcon(icon_settings)
item_settings.setText(self.tr('Settings'))
item_all.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
# Add the items to the list widget
self.menu_list_widget.addItem(item_all)
self.menu_list_widget.addItem(item_installed)
self.menu_list_widget.addItem(item_settings)
# Init the message bar
self.message_bar = QgsMessageBar(self)
self.message_bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.vlayoutRightColumn.insertWidget(0, self.message_bar)
# Progress dialog for long running processes
self.progress_dialog = None
# Init the repository manager dialog
self.repository_manager = RepositoryManager()
self.collection_manager = CollectionManager()
# Collections list view
self.collections_model = QStandardItemModel(0, 1)
self.collections_model.sort(0, Qt.AscendingOrder)
self.collection_proxy = CustomSortFilterProxyModel(self)
self.collection_proxy.setSourceModel(self.collections_model)
self.list_view_collections.setModel(self.collection_proxy)
# Active selected collection
self._selected_collection_id = None
# Slots
self.button_add.clicked.connect(self.add_repository)
self.button_edit.clicked.connect(self.edit_repository)
self.button_delete.clicked.connect(self.delete_repository)
self.button_reload.clicked.connect(self.reload_repositories)
self.menu_list_widget.currentRowChanged.connect(self.set_current_tab)
self.list_view_collections.selectionModel().currentChanged.connect(
self.on_list_view_collections_clicked)
self.line_edit_filter.textChanged.connect(self.filter_collections)
self.button_install.clicked.connect(self.install_collection)
self.button_open.clicked.connect(self.open_collection)
self.button_uninstall.clicked.connect(self.uninstall_collection)
self.button_box.button(QDialogButtonBox.Help).clicked.connect(
self.open_help)
# Populate the repositories widget and collections list view
self.populate_repositories_widget()
self.reload_collections_model()
def set_current_tab(self, index):
"""Set stacked widget based on the active tab.
:param index: The index of the active widget (in the list widget).
:type index: int
"""
# Clear message bar
self.message_bar.clearWidgets()
if index == (self.menu_list_widget.count() - 1):
# Last menu entry - Settings
self.stacked_menu_widget.setCurrentIndex(1)
else:
# Not settings, must be Collections (all or installed)
if index == 1:
# Installed collections
self.collection_proxy.accepted_status = \
COLLECTION_INSTALLED_STATUS
# Set the web view
title = self.tr('Installed Collections')
description = self.tr(
'On the left you see the list of all the '
'installed collections.')
else:
# All collections (0)
self.collection_proxy.accepted_status = COLLECTION_ALL_STATUS
# Set the web view
title = self.tr('All Collections')
description = self.tr(
'On the left you see a list of all the collections '
'that are available from the registered repositories.<br> '
'Installed collections are emphasized (in <b>bold</b>).')
context = {
'resources_path': str(resources_path()),
'title': title,
'description': description
}
self.web_view_details.setHtml(
render_template('tab_description.html', context))
self.stacked_menu_widget.setCurrentIndex(0)
def add_repository(self):
"""Open add repository dialog."""
dlg = ManageRepositoryDialog(self)
if not dlg.exec_():
return
for repoName, repo in self.repository_manager.directories.items():
if dlg.line_edit_url.text().strip() == repo['url']:
self.message_bar.pushMessage(
self.tr(
'Unable to add another repository with the same URL!'),
Qgis.Warning, 5)
return
if dlg.line_edit_name.text().strip() == repoName:
self.message_bar.pushMessage(
self.tr('Repositories must have unique names!'),
Qgis.Warning, 5)
return
repo_name = dlg.line_edit_name.text()
repo_url = dlg.line_edit_url.text().strip()
repo_auth_cfg = dlg.line_edit_auth_id.text().strip()
if repo_name in self.repository_manager.directories:
repo_name += '(2)'
# Show progress dialog
self.show_progress_dialog("Fetching repository's metadata")
# Add repository
try:
status, adderror = self.repository_manager.add_directory(
repo_name, repo_url, repo_auth_cfg)
if status:
self.message_bar.pushMessage(
self.tr('Repository was successfully added'), Qgis.Success,
5)
else:
self.message_bar.pushMessage(
self.tr('Unable to add repository: %s') % adderror,
Qgis.Warning, 5)
except Exception as e:
self.message_bar.pushMessage(self.tr('%s') % e, Qgis.Warning, 5)
finally:
self.progress_dialog.hide()
# Reload data and widget
self.reload_data_and_widget()
# Deactivate edit and delete button
self.button_edit.setEnabled(False)
self.button_delete.setEnabled(False)
def edit_repository(self):
"""Open edit repository dialog."""
selected_item = self.tree_repositories.currentItem()
if selected_item:
repo_name = selected_item.text(0)
if not repo_name:
return
# Check if it is among the officially approved QGIS repositories
settings = QgsSettings()
settings.beginGroup(repo_settings_group())
if settings.value(repo_name + '/url') in \
self.repository_manager._online_directories.values():
self.message_bar.pushMessage(
self.tr('You can not edit the official repositories!'),
Qgis.Warning, 5)
return
dlg = ManageRepositoryDialog(self)
dlg.line_edit_name.setText(repo_name)
dlg.line_edit_url.setText(
self.repository_manager.directories[repo_name]['url'])
dlg.line_edit_auth_id.setText(
self.repository_manager.directories[repo_name]['auth_cfg'])
if not dlg.exec_():
return
# Check if the changed URL is already present and that
# the new repository name is unique
new_url = dlg.line_edit_url.text().strip()
old_url = self.repository_manager.directories[repo_name]['url']
new_name = dlg.line_edit_name.text().strip()
for repoName, repo in self.repository_manager.directories.items():
if new_url == repo['url'] and (old_url != new_url):
self.message_bar.pushMessage(
self.tr('Unable to add another repository with the same '
'URL!'), Qgis.Warning, 5)
return
if new_name == repoName and (repo_name != new_name):
self.message_bar.pushMessage(
self.tr('Repositories must have unique names!'),
Qgis.Warning, 5)
return
# Redundant
if (new_name in self.repository_manager.directories) and (new_name !=
repo_name):
new_name += '(2)'
new_auth_cfg = dlg.line_edit_auth_id.text()
# Show progress dialog
self.show_progress_dialog("Fetching repository's metadata")
# Edit repository
try:
status, editerror = self.repository_manager.edit_directory(
repo_name, new_name, old_url, new_url, new_auth_cfg)
if status:
self.message_bar.pushMessage(
self.tr('Repository is successfully updated'),
Qgis.Success, 5)
else:
self.message_bar.pushMessage(
self.tr('Unable to edit repository: %s') % editerror,
Qgis.Warning, 5)
except Exception as e:
self.message_bar.pushMessage(self.tr('%s') % e, Qgis.Warning, 5)
finally:
self.progress_dialog.hide()
# Reload data and widget
self.reload_data_and_widget()
# Deactivate the edit and delete buttons
self.button_edit.setEnabled(False)
self.button_delete.setEnabled(False)
def delete_repository(self):
"""Delete a repository in the tree widget."""
selected_item = self.tree_repositories.currentItem()
if selected_item:
repo_name = selected_item.text(0)
if not repo_name:
return
# Check if it is among the offical repositories
repo_url = self.repository_manager.directories[repo_name]['url']
if repo_url in self.repository_manager._online_directories.values():
self.message_bar.pushMessage(
self.tr('You can not remove official repositories!'),
Qgis.Warning, 5)
return
warning = self.tr('Are you sure you want to remove the following '
'repository?') + '\n' + repo_name
if QMessageBox.warning(self, self.tr('QGIS Resource Sharing'), warning,
QMessageBox.Yes,
QMessageBox.No) == QMessageBox.No:
return
# Remove repository
installed_collections = \
self.collection_manager.get_installed_collections(repo_url)
if installed_collections:
message = ('You have installed collections from this '
'repository. Please uninstall them first!')
self.message_bar.pushMessage(message, Qgis.Warning, 5)
else:
self.repository_manager.remove_directory(repo_name)
# Reload data and widget
self.reload_data_and_widget()
# Deactivate the edit and delete buttons
self.button_edit.setEnabled(False)
self.button_delete.setEnabled(False)
def reload_repositories(self):
"""Slot for when user clicks reload repositories button."""
# Show progress dialog
self.show_progress_dialog('Reloading all repositories')
for repo_name in self.repository_manager.directories:
directory = self.repository_manager.directories[repo_name]
url = directory['url']
auth_cfg = directory['auth_cfg']
try:
status, reloaderror = self.repository_manager.reload_directory(
repo_name, url, auth_cfg)
if status:
self.message_bar.pushMessage(
self.tr('Repository %s is successfully reloaded') %
repo_name, Qgis.Info, 5)
else:
self.message_bar.pushMessage(
self.tr('Unable to reload %s: %s') %
(repo_name, reloaderror), Qgis.Warning, 5)
except Exception as e:
self.message_bar.pushMessage(
self.tr('%s') % e, Qgis.Warning, 5)
self.progress_dialog.hide()
# Reload data and widget
self.reload_data_and_widget()
def install_collection(self):
"""Slot for when the user clicks the install/reinstall button."""
# Save the current index to enable selection after installation
self.current_index = self.list_view_collections.currentIndex()
self.show_progress_dialog('Starting installation...')
self.progress_dialog.canceled.connect(self.install_canceled)
self.installer_thread = QThread()
self.installer_worker = CollectionInstaller(
self.collection_manager, self._selected_collection_id)
self.installer_worker.moveToThread(self.installer_thread)
self.installer_worker.finished.connect(self.install_finished)
self.installer_worker.aborted.connect(self.install_aborted)
self.installer_worker.progress.connect(self.install_progress)
self.installer_thread.started.connect(self.installer_worker.run)
self.installer_thread.start()
def install_finished(self):
# Process the result
self.progress_dialog.hide()
installStatus = self.installer_worker.install_status
if not installStatus:
message = self.installer_worker.error_message
# Clean up the worker and thread
self.installer_worker.deleteLater()
self.installer_thread.quit()
self.installer_thread.wait()
self.installer_thread.deleteLater()
if installStatus:
self.reload_collections_model()
# Report what has been installed
message = '<b>%s</b> was successfully installed, containing:\n<ul>' % (
config.COLLECTIONS[self._selected_collection_id]['name'])
number = 0
if 'style' in config.COLLECTIONS[
self._selected_collection_id].keys():
number = config.COLLECTIONS[
self._selected_collection_id]['style']
message = message + '\n<li> ' + str(
number) + ' Layer style (QML) file'
if number > 1:
message = message + 's'
if 'symbol' in config.COLLECTIONS[
self._selected_collection_id].keys():
number = config.COLLECTIONS[
self._selected_collection_id]['symbol']
message = message + '\n<li> ' + str(
number) + ' XML symbol file'
if number > 1:
message = message + 's'
if 'svg' in config.COLLECTIONS[
self._selected_collection_id].keys():
number = config.COLLECTIONS[
self._selected_collection_id]['svg']
message = message + '\n<li> ' + str(number) + ' SVG file'
if number > 1:
message = message + 's'
if 'models' in config.COLLECTIONS[
self._selected_collection_id].keys():
number = config.COLLECTIONS[
self._selected_collection_id]['models']
message = message + '\n<li> ' + str(number) + ' model'
if number > 1:
message = message + 's'
if 'expressions' in config.COLLECTIONS[
self._selected_collection_id].keys():
number = config.COLLECTIONS[
self._selected_collection_id]['expressions']
message = message + '\n<li> ' + str(
number) + ' expression file'
if number > 1:
message = message + 's'
if 'processing' in config.COLLECTIONS[
self._selected_collection_id].keys():
number = config.COLLECTIONS[
self._selected_collection_id]['processing']
message = message + '\n<li> ' + str(
number) + ' processing script'
if number > 1:
message = message + 's'
if 'rscripts' in config.COLLECTIONS[
self._selected_collection_id].keys():
number = config.COLLECTIONS[
self._selected_collection_id]['rscripts']
message = message + '\n<li> ' + str(number) + ' R script'
if number > 1:
message = message + 's'
message = message + '\n</ul>'
QMessageBox.information(self, 'Resource Sharing', message)
self.populate_repositories_widget()
# Set the selection
oldRow = self.current_index.row()
newIndex = self.collections_model.createIndex(oldRow, 0)
selection_model = self.list_view_collections.selectionModel()
selection_model.setCurrentIndex(newIndex,
selection_model.ClearAndSelect)
selection_model.select(newIndex, selection_model.ClearAndSelect)
# Update the buttons
self.button_install.setEnabled(True)
self.button_install.setText('Reinstall')
self.button_open.setEnabled(True)
self.button_uninstall.setEnabled(True)
self.show_collection_metadata(self._selected_collection_id)
def install_canceled(self):
self.progress_dialog.hide()
self.show_progress_dialog('Cancelling installation...')
self.installer_worker.abort()
def install_aborted(self):
if self.installer_thread.isRunning():
self.installer_thread.quit()
self.installer_thread.finished.connect(self.progress_dialog.hide)
def install_progress(self, text):
self.progress_dialog.setLabelText(text)
def uninstall_collection(self):
"""Slot called when user clicks the uninstall button."""
# get the QModelIndex for the item to be uninstalled
uninstall_index = self.list_view_collections.currentIndex()
coll_id = self._selected_collection_id
try:
self.collection_manager.uninstall(coll_id)
except Exception as e:
LOGGER.error('Could not uninstall collection ' +
config.COLLECTIONS[coll_id]['name'] + ':\n' + str(e))
else:
QMessageBox.information(
self, 'Resource Sharing',
'The collection was successfully uninstalled!')
self.reload_collections_model()
# Fix the GUI
currentMenuRow = self.menu_list_widget.currentRow()
self.set_current_tab(currentMenuRow)
self.populate_repositories_widget()
rowCount = self.collection_proxy.rowCount()
if rowCount > 0:
# Set the current (and selected) row in the listview
newRow = uninstall_index.row()
# Check if this was the last element
rowCount = self.collection_proxy.rowCount()
if newRow == rowCount:
newRow = newRow - 1
# Select the new current element
newIndex = self.collections_model.createIndex(newRow, 0)
selection_model = self.list_view_collections.selectionModel()
selection_model.setCurrentIndex(newIndex,
selection_model.ClearAndSelect)
# Get the id of the current collection
proxyModel = self.list_view_collections.model()
proxyIndex = proxyModel.index(newRow, 0)
current_coll_id = proxyIndex.data(COLLECTION_ID_ROLE)
self._selected_collection_id = current_coll_id
# Update buttons
status = config.COLLECTIONS[current_coll_id]['status']
if status == COLLECTION_INSTALLED_STATUS:
self.button_install.setEnabled(True)
self.button_install.setText('Reinstall')
self.button_open.setEnabled(True)
self.button_uninstall.setEnabled(True)
else:
self.button_install.setEnabled(True)
self.button_install.setText('Install')
self.button_open.setEnabled(False)
self.button_uninstall.setEnabled(False)
# Update the web_view_details frame
self.show_collection_metadata(current_coll_id)
else:
self.button_install.setEnabled(False)
self.button_install.setText('Install')
self.button_open.setEnabled(False)
self.button_uninstall.setEnabled(False)
def open_collection(self):
"""Slot for when user clicks 'Open' button."""
collection_path = local_collection_path(self._selected_collection_id)
directory_url = QUrl.fromLocalFile(str(collection_path))
QDesktopServices.openUrl(directory_url)
def reload_data_and_widget(self):
"""Reload repositories and collections and update widgets related."""
self.reload_repositories_widget()
self.reload_collections_model()
def reload_repositories_widget(self):
"""Refresh tree repositories using new repositories data."""
self.repository_manager.load_directories()
self.populate_repositories_widget()
def populate_repositories_widget(self):
"""Populate the current dictionary repositories to the tree widget."""
# Clear the current tree widget
self.tree_repositories.clear()
installed_collections = \
self.collection_manager.get_installed_collections()
# Export the updated ones from the repository manager
for repo_name in self.repository_manager.directories:
url = self.repository_manager.directories[repo_name]['url']
item = QTreeWidgetItem(self.tree_repositories, REPOSITORY_ITEM)
item.setText(0, repo_name)
item.setText(1, url)
for coll_id in config.COLLECTIONS:
if ('repository_name' in config.COLLECTIONS[coll_id].keys()
and config.COLLECTIONS[coll_id]['repository_name']
== repo_name):
coll_name = config.COLLECTIONS[coll_id]['name']
coll_tags = config.COLLECTIONS[coll_id]['tags']
collectionItem = QTreeWidgetItem(item, COLLECTION_ITEM)
collitemtext = coll_name
if installed_collections and coll_id in installed_collections.keys(
):
collitemtext = coll_name + ' (installed)'
collectionFont = QFont()
collectionFont.setWeight(60)
collectionItem.setFont(0, collectionFont)
collectionItem.setText(0, collitemtext)
collectionItem.setText(1, coll_tags)
self.tree_repositories.resizeColumnToContents(0)
self.tree_repositories.resizeColumnToContents(1)
self.tree_repositories.sortItems(1, Qt.AscendingOrder)
def reload_collections_model(self):
"""Reload the collections model with the current collections."""
self.collections_model.clear()
installed_collections = \
self.collection_manager.get_installed_collections()
for id in config.COLLECTIONS:
collection_name = config.COLLECTIONS[id]['name']
collection_author = config.COLLECTIONS[id]['author']
collection_tags = config.COLLECTIONS[id]['tags']
collection_description = config.COLLECTIONS[id]['description']
collection_status = config.COLLECTIONS[id]['status']
repository_name = ''
if 'repository_name' in config.COLLECTIONS[id].keys():
repository_name = config.COLLECTIONS[id]['repository_name']
item = QStandardItem(collection_name + ' (' + repository_name +
')')
item.setEditable(False)
item.setData(id, COLLECTION_ID_ROLE)
item.setData(collection_name, COLLECTION_NAME_ROLE)
item.setData(collection_description, COLLECTION_DESCRIPTION_ROLE)
item.setData(collection_author, COLLECTION_AUTHOR_ROLE)
item.setData(collection_tags, COLLECTION_TAGS_ROLE)
item.setData(collection_status, COLLECTION_STATUS_ROLE)
# Make installed collections stand out
if installed_collections and id in installed_collections.keys():
collectionFont = QFont()
collectionFont.setWeight(60)
item.setFont(collectionFont)
self.collections_model.appendRow(item)
self.collections_model.sort(0, Qt.AscendingOrder)
def on_tree_repositories_itemSelectionChanged(self):
"""Slot for the itemSelectionChanged signal of tree_repositories."""
selected_item = self.tree_repositories.currentItem()
if selected_item and selected_item.type() == REPOSITORY_ITEM:
if selected_item:
repo_name = selected_item.text(0)
if not repo_name:
return
if not repo_name in self.repository_manager.directories.keys():
return
repo_url = self.repository_manager.directories[repo_name]['url']
# Disable the edit and delete buttons for "official" repositories
if repo_url in self.repository_manager._online_directories.values(
):
self.button_edit.setEnabled(False)
self.button_delete.setEnabled(False)
else:
# Activate the edit and delete buttons
self.button_edit.setEnabled(True)
self.button_delete.setEnabled(True)
elif selected_item and selected_item.type() == COLLECTION_ITEM:
self.button_edit.setEnabled(False)
self.button_delete.setEnabled(False)
else:
self.button_edit.setEnabled(False)
self.button_delete.setEnabled(False)
def on_list_view_collections_clicked(self, index):
"""Slot for when the list_view_collections is clicked."""
real_index = self.collection_proxy.mapToSource(index)
if real_index.row() != -1:
collection_item = self.collections_model.itemFromIndex(real_index)
collection_id = collection_item.data(COLLECTION_ID_ROLE)
self._selected_collection_id = collection_id
# Enable / disable buttons
status = config.COLLECTIONS[self._selected_collection_id]['status']
is_installed = status == COLLECTION_INSTALLED_STATUS
if is_installed:
self.button_install.setEnabled(True)
self.button_install.setText('Reinstall')
self.button_open.setEnabled(True)
self.button_uninstall.setEnabled(True)
else:
self.button_install.setEnabled(True)
self.button_install.setText('Install')
self.button_open.setEnabled(False)
self.button_uninstall.setEnabled(False)
# Show metadata
self.show_collection_metadata(collection_id)
@pyqtSlot(str)
def filter_collections(self, text):
search = QRegExp(text, Qt.CaseInsensitive, QRegExp.RegExp)
self.collection_proxy.setFilterRegExp(search)
def show_collection_metadata(self, id):
"""Show the collection metadata given the ID."""
html = self.collection_manager.get_html(id)
self.web_view_details.setHtml(html)
def reject(self):
"""Slot when the dialog is closed."""
# Serialize collections to settings
self.repository_manager.serialize_repositories()
self.done(0)
def open_help(self):
"""Open help."""
doc_url = QUrl('http://qgis-contribution.github.io/' +
'QGIS-ResourceSharing/')
QDesktopServices.openUrl(doc_url)
def show_progress_dialog(self, text):
"""Show infinite progress dialog with given text.
:param text: Text as the label of the progress dialog
:type text: str
"""
if self.progress_dialog is None:
self.progress_dialog = QProgressDialog(self)
self.progress_dialog.setWindowModality(Qt.WindowModal)
self.progress_dialog.setAutoClose(False)
title = self.tr('Resource Sharing')
self.progress_dialog.setWindowTitle(title)
# Just use an infinite progress bar here
self.progress_dialog.setMaximum(0)
self.progress_dialog.setMinimum(0)
self.progress_dialog.setValue(0)
self.progress_dialog.setLabelText(text)
self.progress_dialog.show()
class DlgSqlWindow(QWidget, Ui_Dialog):
nameChanged = pyqtSignal(str)
QUERY_HISTORY_LIMIT = 20
def __init__(self, iface, db, parent=None):
QWidget.__init__(self, parent)
self.mainWindow = parent
self.iface = iface
self.db = db
self.dbType = db.connection().typeNameString()
self.connectionName = db.connection().connectionName()
self.filter = ""
self.modelAsync = None
self.allowMultiColumnPk = isinstance(db, PGDatabase) # at the moment only PostgreSQL allows a primary key to span multiple columns, SpatiaLite doesn't
self.aliasSubQuery = isinstance(db, PGDatabase) # only PostgreSQL requires subqueries to be aliases
self.setupUi(self)
self.setWindowTitle(
self.tr(u"{0} - {1} [{2}]").format(self.windowTitle(), self.connectionName, self.dbType))
self.defaultLayerName = self.tr('QueryLayer')
if self.allowMultiColumnPk:
self.uniqueColumnCheck.setText(self.tr("Column(s) with unique values"))
else:
self.uniqueColumnCheck.setText(self.tr("Column with unique values"))
self.editSql.setFocus()
self.editSql.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.editSql.setMarginVisible(True)
self.initCompleter()
settings = QgsSettings()
self.history = settings.value('DB_Manager/queryHistory/' + self.dbType, {self.connectionName: []})
if self.connectionName not in self.history:
self.history[self.connectionName] = []
self.queryHistoryWidget.setVisible(False)
self.queryHistoryTableWidget.verticalHeader().hide()
self.queryHistoryTableWidget.doubleClicked.connect(self.insertQueryInEditor)
self.populateQueryHistory()
self.btnQueryHistory.toggled.connect(self.showHideQueryHistory)
self.btnCancel.setEnabled(False)
self.btnCancel.clicked.connect(self.executeSqlCanceled)
self.btnCancel.setShortcut(QKeySequence.Cancel)
self.progressBar.setEnabled(False)
self.progressBar.setRange(0, 100)
self.progressBar.setValue(0)
self.progressBar.setFormat("")
self.progressBar.setAlignment(Qt.AlignCenter)
# allow copying results
copyAction = QAction("copy", self)
self.viewResult.addAction(copyAction)
copyAction.setShortcuts(QKeySequence.Copy)
copyAction.triggered.connect(self.copySelectedResults)
self.btnExecute.clicked.connect(self.executeSql)
self.btnSetFilter.clicked.connect(self.setFilter)
self.btnClear.clicked.connect(self.clearSql)
self.presetStore.clicked.connect(self.storePreset)
self.presetSaveAsFile.clicked.connect(self.saveAsFilePreset)
self.presetLoadFile.clicked.connect(self.loadFilePreset)
self.presetDelete.clicked.connect(self.deletePreset)
self.presetCombo.activated[str].connect(self.loadPreset)
self.presetCombo.activated[str].connect(self.presetName.setText)
self.updatePresetsCombobox()
self.geomCombo.setEditable(True)
self.geomCombo.lineEdit().setReadOnly(True)
self.uniqueCombo.setEditable(True)
self.uniqueCombo.lineEdit().setReadOnly(True)
self.uniqueModel = QStandardItemModel(self.uniqueCombo)
self.uniqueCombo.setModel(self.uniqueModel)
if self.allowMultiColumnPk:
self.uniqueCombo.setItemDelegate(QStyledItemDelegate())
self.uniqueModel.itemChanged.connect(self.uniqueChanged) # react to the (un)checking of an item
self.uniqueCombo.lineEdit().textChanged.connect(self.uniqueTextChanged) # there are other events that change the displayed text and some of them can not be caught directly
# hide the load query as layer if feature is not supported
self._loadAsLayerAvailable = self.db.connector.hasCustomQuerySupport()
self.loadAsLayerGroup.setVisible(self._loadAsLayerAvailable)
if self._loadAsLayerAvailable:
self.layerTypeWidget.hide() # show if load as raster is supported
self.loadLayerBtn.clicked.connect(self.loadSqlLayer)
self.getColumnsBtn.clicked.connect(self.fillColumnCombos)
self.loadAsLayerGroup.toggled.connect(self.loadAsLayerToggled)
self.loadAsLayerToggled(False)
self._createViewAvailable = self.db.connector.hasCreateSpatialViewSupport()
self.btnCreateView.setVisible(self._createViewAvailable)
if self._createViewAvailable:
self.btnCreateView.clicked.connect(self.createView)
self.queryBuilderFirst = True
self.queryBuilderBtn.setIcon(QIcon(":/db_manager/icons/sql.gif"))
self.queryBuilderBtn.clicked.connect(self.displayQueryBuilder)
self.presetName.textChanged.connect(self.nameChanged)
def insertQueryInEditor(self, item):
sql = item.data(Qt.DisplayRole)
self.editSql.insertText(sql)
def showHideQueryHistory(self, visible):
self.queryHistoryWidget.setVisible(visible)
def populateQueryHistory(self):
self.queryHistoryTableWidget.clearContents()
self.queryHistoryTableWidget.setRowCount(0)
dictlist = self.history[self.connectionName]
if not dictlist:
return
for i in range(len(dictlist)):
self.queryHistoryTableWidget.insertRow(0)
queryItem = QTableWidgetItem(dictlist[i]['query'])
rowsItem = QTableWidgetItem(str(dictlist[i]['rows']))
durationItem = QTableWidgetItem(str(dictlist[i]['secs']))
self.queryHistoryTableWidget.setItem(0, 0, queryItem)
self.queryHistoryTableWidget.setItem(0, 1, rowsItem)
self.queryHistoryTableWidget.setItem(0, 2, durationItem)
self.queryHistoryTableWidget.resizeColumnsToContents()
self.queryHistoryTableWidget.resizeRowsToContents()
def writeQueryHistory(self, sql, affectedRows, secs):
if len(self.history[self.connectionName]) >= self.QUERY_HISTORY_LIMIT:
self.history[self.connectionName].pop(0)
settings = QgsSettings()
self.history[self.connectionName].append({'query': sql,
'rows': affectedRows,
'secs': secs})
settings.setValue('DB_Manager/queryHistory/' + self.dbType, self.history)
self.populateQueryHistory()
def getQueryHash(self, name):
return 'q%s' % md5(name.encode('utf8')).hexdigest()
def updatePresetsCombobox(self):
self.presetCombo.clear()
names = []
entries = QgsProject.instance().subkeyList('DBManager', 'savedQueries')
for entry in entries:
name = QgsProject.instance().readEntry('DBManager', 'savedQueries/' + entry + '/name')[0]
names.append(name)
for name in sorted(names):
self.presetCombo.addItem(name)
self.presetCombo.setCurrentIndex(-1)
def storePreset(self):
query = self._getSqlQuery()
if query == "":
return
name = str(self.presetName.text())
QgsProject.instance().writeEntry('DBManager', 'savedQueries/' + self.getQueryHash(name) + '/name', name)
QgsProject.instance().writeEntry('DBManager', 'savedQueries/' + self.getQueryHash(name) + '/query', query)
index = self.presetCombo.findText(name)
if index == -1:
self.presetCombo.addItem(name)
self.presetCombo.setCurrentIndex(self.presetCombo.count() - 1)
else:
self.presetCombo.setCurrentIndex(index)
def saveAsFilePreset(self):
settings = QgsSettings()
lastDir = settings.value('DB_Manager/lastDirSQLFIle', "")
query = self._getSqlQuery()
if query == "":
return
filename, _ = QFileDialog.getSaveFileName(
self,
self.tr('Save SQL Query'),
lastDir,
self.tr("SQL File (*.sql, *.SQL)"))
if filename:
if not filename.lower().endswith('.sql'):
filename += ".sql"
with open(filename, 'w') as f:
f.write(query)
lastDir = os.path.dirname(filename)
settings.setValue('DB_Manager/lastDirSQLFile', lastDir)
def loadFilePreset(self):
settings = QgsSettings()
lastDir = settings.value('DB_Manager/lastDirSQLFIle', "")
filename, _ = QFileDialog.getOpenFileName(
self,
self.tr("Load SQL Query"),
lastDir,
self.tr("SQL File (*.sql, *.SQL)"))
if filename:
with open(filename, 'r') as f:
self.editSql.clear()
for line in f:
self.editSql.insertText(line)
lastDir = os.path.dirname(filename)
settings.setValue('DB_Manager/lastDirSQLFile', lastDir)
def deletePreset(self):
name = self.presetCombo.currentText()
QgsProject.instance().removeEntry('DBManager', 'savedQueries/' + self.getQueryHash(name))
self.presetCombo.removeItem(self.presetCombo.findText(name))
self.presetCombo.setCurrentIndex(-1)
def loadPreset(self, name):
query = QgsProject.instance().readEntry('DBManager', 'savedQueries/' + self.getQueryHash(name) + '/query')[0]
self.editSql.setText(query)
def loadAsLayerToggled(self, checked):
self.loadAsLayerGroup.setChecked(checked)
self.loadAsLayerWidget.setVisible(checked)
if checked:
self.fillColumnCombos()
def clearSql(self):
self.editSql.clear()
self.editSql.setFocus()
self.filter = ""
def updateUiWhileSqlExecution(self, status):
if status:
for i in range(0, self.mainWindow.tabs.count()):
if i != self.mainWindow.tabs.currentIndex():
self.mainWindow.tabs.setTabEnabled(i, False)
self.mainWindow.menuBar.setEnabled(False)
self.mainWindow.toolBar.setEnabled(False)
self.mainWindow.tree.setEnabled(False)
for w in self.findChildren(QWidget):
w.setEnabled(False)
self.btnCancel.setEnabled(True)
self.progressBar.setEnabled(True)
self.progressBar.setRange(0, 0)
else:
for i in range(0, self.mainWindow.tabs.count()):
if i != self.mainWindow.tabs.currentIndex():
self.mainWindow.tabs.setTabEnabled(i, True)
self.mainWindow.refreshTabs()
self.mainWindow.menuBar.setEnabled(True)
self.mainWindow.toolBar.setEnabled(True)
self.mainWindow.tree.setEnabled(True)
for w in self.findChildren(QWidget):
w.setEnabled(True)
self.btnCancel.setEnabled(False)
self.progressBar.setRange(0, 100)
self.progressBar.setEnabled(False)
def executeSqlCanceled(self):
self.btnCancel.setEnabled(False)
self.modelAsync.cancel()
def executeSqlCompleted(self):
self.updateUiWhileSqlExecution(False)
with OverrideCursor(Qt.WaitCursor):
if self.modelAsync.task.status() == QgsTask.Complete:
model = self.modelAsync.model
quotedCols = []
self.viewResult.setModel(model)
self.lblResult.setText(self.tr("{0} rows, {1:.3f} seconds").format(model.affectedRows(), model.secs()))
cols = self.viewResult.model().columnNames()
for col in cols:
quotedCols.append(self.db.connector.quoteId(col))
self.setColumnCombos(cols, quotedCols)
self.writeQueryHistory(self.modelAsync.task.sql, model.affectedRows(), model.secs())
self.update()
elif not self.modelAsync.canceled:
DlgDbError.showError(self.modelAsync.error, self)
self.uniqueModel.clear()
self.geomCombo.clear()
def executeSql(self):
sql = self._getExecutableSqlQuery()
if sql == "":
return
# delete the old model
old_model = self.viewResult.model()
self.viewResult.setModel(None)
if old_model:
old_model.deleteLater()
try:
self.modelAsync = self.db.sqlResultModelAsync(sql, self)
self.modelAsync.done.connect(self.executeSqlCompleted)
self.updateUiWhileSqlExecution(True)
QgsApplication.taskManager().addTask(self.modelAsync.task)
except Exception as e:
DlgDbError.showError(e, self)
self.uniqueModel.clear()
self.geomCombo.clear()
return
def _getSqlLayer(self, _filter):
hasUniqueField = self.uniqueColumnCheck.checkState() == Qt.Checked
if hasUniqueField:
if self.allowMultiColumnPk:
checkedCols = []
for item in self.uniqueModel.findItems("*", Qt.MatchWildcard):
if item.checkState() == Qt.Checked:
checkedCols.append(item.data())
uniqueFieldName = ",".join(checkedCols)
elif self.uniqueCombo.currentIndex() >= 0:
uniqueFieldName = self.uniqueModel.item(self.uniqueCombo.currentIndex()).data()
else:
uniqueFieldName = None
else:
uniqueFieldName = None
hasGeomCol = self.hasGeometryCol.checkState() == Qt.Checked
if hasGeomCol:
geomFieldName = self.geomCombo.currentText()
else:
geomFieldName = None
query = self._getExecutableSqlQuery()
if query == "":
return None
# remove a trailing ';' from query if present
if query.strip().endswith(';'):
query = query.strip()[:-1]
layerType = QgsMapLayerType.VectorLayer if self.vectorRadio.isChecked() else QgsMapLayerType.RasterLayer
# get a new layer name
names = []
for layer in list(QgsProject.instance().mapLayers().values()):
names.append(layer.name())
layerName = self.layerNameEdit.text()
if layerName == "":
layerName = self.defaultLayerName
newLayerName = layerName
index = 1
while newLayerName in names:
index += 1
newLayerName = u"%s_%d" % (layerName, index)
# create the layer
layer = self.db.toSqlLayer(query, geomFieldName, uniqueFieldName, newLayerName, layerType,
self.avoidSelectById.isChecked(), _filter)
if layer.isValid():
return layer
else:
e = BaseError(self.tr("There was an error creating the SQL layer, please check the logs for further information."))
DlgDbError.showError(e, self)
return None
def loadSqlLayer(self):
with OverrideCursor(Qt.WaitCursor):
layer = self._getSqlLayer(self.filter)
if layer is None:
return
QgsProject.instance().addMapLayers([layer], True)
def fillColumnCombos(self):
query = self._getExecutableSqlQuery()
if query == "":
return
with OverrideCursor(Qt.WaitCursor):
# remove a trailing ';' from query if present
if query.strip().endswith(';'):
query = query.strip()[:-1]
# get all the columns
quotedCols = []
connector = self.db.connector
if self.aliasSubQuery:
# get a new alias
aliasIndex = 0
while True:
alias = "_subQuery__%d" % aliasIndex
escaped = re.compile('\\b("?)' + re.escape(alias) + '\\1\\b')
if not escaped.search(query):
break
aliasIndex += 1
sql = u"SELECT * FROM (%s\n) AS %s LIMIT 0" % (str(query), connector.quoteId(alias))
else:
sql = u"SELECT * FROM (%s\n) WHERE 1=0" % str(query)
c = None
try:
c = connector._execute(None, sql)
cols = connector._get_cursor_columns(c)
for col in cols:
quotedCols.append(connector.quoteId(col))
except BaseError as e:
DlgDbError.showError(e, self)
self.uniqueModel.clear()
self.geomCombo.clear()
return
finally:
if c:
c.close()
del c
self.setColumnCombos(cols, quotedCols)
def setColumnCombos(self, cols, quotedCols):
# get sensible default columns. do this before sorting in case there's hints in the column order (e.g., id is more likely to be first)
try:
defaultGeomCol = next(col for col in cols if col in ['geom', 'geometry', 'the_geom', 'way'])
except:
defaultGeomCol = None
try:
defaultUniqueCol = [col for col in cols if 'id' in col][0]
except:
defaultUniqueCol = None
colNames = sorted(zip(cols, quotedCols))
newItems = []
uniqueIsFilled = False
for (col, quotedCol) in colNames:
item = QStandardItem(col)
item.setData(quotedCol)
item.setEnabled(True)
item.setCheckable(self.allowMultiColumnPk)
item.setSelectable(not self.allowMultiColumnPk)
if self.allowMultiColumnPk:
matchingItems = self.uniqueModel.findItems(col)
if matchingItems:
item.setCheckState(matchingItems[0].checkState())
uniqueIsFilled = uniqueIsFilled or matchingItems[0].checkState() == Qt.Checked
else:
item.setCheckState(Qt.Unchecked)
newItems.append(item)
if self.allowMultiColumnPk:
self.uniqueModel.clear()
self.uniqueModel.appendColumn(newItems)
self.uniqueChanged()
else:
previousUniqueColumn = self.uniqueCombo.currentText()
self.uniqueModel.clear()
self.uniqueModel.appendColumn(newItems)
if self.uniqueModel.findItems(previousUniqueColumn):
self.uniqueCombo.setEditText(previousUniqueColumn)
uniqueIsFilled = True
oldGeometryColumn = self.geomCombo.currentText()
self.geomCombo.clear()
self.geomCombo.addItems(cols)
self.geomCombo.setCurrentIndex(self.geomCombo.findText(oldGeometryColumn, Qt.MatchExactly))
# set sensible default columns if the columns are not already set
try:
if self.geomCombo.currentIndex() == -1:
self.geomCombo.setCurrentIndex(cols.index(defaultGeomCol))
except:
pass
items = self.uniqueModel.findItems(defaultUniqueCol)
if items and not uniqueIsFilled:
if self.allowMultiColumnPk:
items[0].setCheckState(Qt.Checked)
else:
self.uniqueCombo.setEditText(defaultUniqueCol)
def copySelectedResults(self):
if len(self.viewResult.selectedIndexes()) <= 0:
return
model = self.viewResult.model()
# convert to string using tab as separator
text = model.headerToString("\t")
for idx in self.viewResult.selectionModel().selectedRows():
text += "\n" + model.rowToString(idx.row(), "\t")
QApplication.clipboard().setText(text, QClipboard.Selection)
QApplication.clipboard().setText(text, QClipboard.Clipboard)
def initCompleter(self):
dictionary = None
if self.db:
dictionary = self.db.connector.getSqlDictionary()
if not dictionary:
# use the generic sql dictionary
from .sql_dictionary import getSqlDictionary
dictionary = getSqlDictionary()
wordlist = []
for value in dictionary.values():
wordlist += value # concat lists
wordlist = list(set(wordlist)) # remove duplicates
api = QsciAPIs(self.editSql.lexer())
for word in wordlist:
api.add(word)
api.prepare()
self.editSql.lexer().setAPIs(api)
def displayQueryBuilder(self):
dlg = QueryBuilderDlg(self.iface, self.db, self, reset=self.queryBuilderFirst)
self.queryBuilderFirst = False
r = dlg.exec_()
if r == QDialog.Accepted:
self.editSql.setText(dlg.query)
def createView(self):
name, ok = QInputDialog.getText(None, self.tr("View Name"), self.tr("View name"))
if ok:
try:
self.db.connector.createSpatialView(name, self._getExecutableSqlQuery())
except BaseError as e:
DlgDbError.showError(e, self)
def _getSqlQuery(self):
sql = self.editSql.selectedText()
if len(sql) == 0:
sql = self.editSql.text()
return sql
def _getExecutableSqlQuery(self):
sql = self._getSqlQuery()
# Clean it up!
lines = []
for line in sql.split('\n'):
if not line.strip().startswith('--'):
lines.append(line)
sql = ' '.join(lines)
return sql.strip()
def uniqueChanged(self):
# when an item is (un)checked, simply trigger an update of the combobox text
self.uniqueTextChanged(None)
def uniqueTextChanged(self, text):
# Whenever there is new text displayed in the combobox, check if it is the correct one and if not, display the correct one.
checkedItems = []
for item in self.uniqueModel.findItems("*", Qt.MatchWildcard):
if item.checkState() == Qt.Checked:
checkedItems.append(item.text())
label = ", ".join(checkedItems)
if text != label:
self.uniqueCombo.setEditText(label)
def setFilter(self):
from qgis.gui import QgsQueryBuilder
layer = self._getSqlLayer("")
if not layer:
return
dlg = QgsQueryBuilder(layer)
dlg.setSql(self.filter)
if dlg.exec_():
self.filter = dlg.sql()
layer.deleteLater()
class DlgSqlWindow(QWidget, Ui_Dialog):
nameChanged = pyqtSignal(str)
def __init__(self, iface, db, parent=None):
QWidget.__init__(self, parent)
self.iface = iface
self.db = db
self.filter = ""
self.allowMultiColumnPk = isinstance(db, PGDatabase) # at the moment only PostgreSQL allows a primary key to span multiple columns, spatialite doesn't
self.aliasSubQuery = isinstance(db, PGDatabase) # only PostgreSQL requires subqueries to be aliases
self.setupUi(self)
self.setWindowTitle(
u"%s - %s [%s]" % (self.windowTitle(), db.connection().connectionName(), db.connection().typeNameString()))
self.defaultLayerName = 'QueryLayer'
if self.allowMultiColumnPk:
self.uniqueColumnCheck.setText(self.tr("Column(s) with unique values"))
else:
self.uniqueColumnCheck.setText(self.tr("Column with unique values"))
self.editSql.setFocus()
self.editSql.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.editSql.setMarginVisible(True)
self.initCompleter()
# allow copying results
copyAction = QAction("copy", self)
self.viewResult.addAction(copyAction)
copyAction.setShortcuts(QKeySequence.Copy)
copyAction.triggered.connect(self.copySelectedResults)
self.btnExecute.clicked.connect(self.executeSql)
self.btnSetFilter.clicked.connect(self.setFilter)
self.btnClear.clicked.connect(self.clearSql)
self.presetStore.clicked.connect(self.storePreset)
self.presetDelete.clicked.connect(self.deletePreset)
self.presetCombo.activated[str].connect(self.loadPreset)
self.presetCombo.activated[str].connect(self.presetName.setText)
self.updatePresetsCombobox()
self.geomCombo.setEditable(True)
self.geomCombo.lineEdit().setReadOnly(True)
self.uniqueCombo.setEditable(True)
self.uniqueCombo.lineEdit().setReadOnly(True)
self.uniqueModel = QStandardItemModel(self.uniqueCombo)
self.uniqueCombo.setModel(self.uniqueModel)
if self.allowMultiColumnPk:
self.uniqueCombo.setItemDelegate(QStyledItemDelegate())
self.uniqueModel.itemChanged.connect(self.uniqueChanged) # react to the (un)checking of an item
self.uniqueCombo.lineEdit().textChanged.connect(self.uniqueTextChanged) # there are other events that change the displayed text and some of them can not be caught directly
# hide the load query as layer if feature is not supported
self._loadAsLayerAvailable = self.db.connector.hasCustomQuerySupport()
self.loadAsLayerGroup.setVisible(self._loadAsLayerAvailable)
if self._loadAsLayerAvailable:
self.layerTypeWidget.hide() # show if load as raster is supported
self.loadLayerBtn.clicked.connect(self.loadSqlLayer)
self.getColumnsBtn.clicked.connect(self.fillColumnCombos)
self.loadAsLayerGroup.toggled.connect(self.loadAsLayerToggled)
self.loadAsLayerToggled(False)
self._createViewAvailable = self.db.connector.hasCreateSpatialViewSupport()
self.btnCreateView.setVisible(self._createViewAvailable)
if self._createViewAvailable:
self.btnCreateView.clicked.connect(self.createView)
self.queryBuilderFirst = True
self.queryBuilderBtn.setIcon(QIcon(":/db_manager/icons/sql.gif"))
self.queryBuilderBtn.clicked.connect(self.displayQueryBuilder)
self.presetName.textChanged.connect(self.nameChanged)
def updatePresetsCombobox(self):
self.presetCombo.clear()
names = []
entries = QgsProject.instance().subkeyList('DBManager', 'savedQueries')
for entry in entries:
name = QgsProject.instance().readEntry('DBManager', 'savedQueries/' + entry + '/name')[0]
names.append(name)
for name in sorted(names):
self.presetCombo.addItem(name)
self.presetCombo.setCurrentIndex(-1)
def storePreset(self):
query = self._getSqlQuery()
if query == "":
return
name = self.presetName.text()
QgsProject.instance().writeEntry('DBManager', 'savedQueries/q' + str(name.__hash__()) + '/name', name)
QgsProject.instance().writeEntry('DBManager', 'savedQueries/q' + str(name.__hash__()) + '/query', query)
index = self.presetCombo.findText(name)
if index == -1:
self.presetCombo.addItem(name)
self.presetCombo.setCurrentIndex(self.presetCombo.count() - 1)
else:
self.presetCombo.setCurrentIndex(index)
def deletePreset(self):
name = self.presetCombo.currentText()
QgsProject.instance().removeEntry('DBManager', 'savedQueries/q' + str(name.__hash__()))
self.presetCombo.removeItem(self.presetCombo.findText(name))
self.presetCombo.setCurrentIndex(-1)
def loadPreset(self, name):
query = QgsProject.instance().readEntry('DBManager', 'savedQueries/q' + str(name.__hash__()) + '/query')[0]
name = QgsProject.instance().readEntry('DBManager', 'savedQueries/q' + str(name.__hash__()) + '/name')[0]
self.editSql.setText(query)
def loadAsLayerToggled(self, checked):
self.loadAsLayerGroup.setChecked(checked)
self.loadAsLayerWidget.setVisible(checked)
if checked:
self.fillColumnCombos()
def clearSql(self):
self.editSql.clear()
self.editSql.setFocus()
self.filter = ""
def executeSql(self):
sql = self._getSqlQuery()
if sql == "":
return
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
# delete the old model
old_model = self.viewResult.model()
self.viewResult.setModel(None)
if old_model:
old_model.deleteLater()
cols = []
quotedCols = []
try:
# set the new model
model = self.db.sqlResultModel(sql, self)
self.viewResult.setModel(model)
self.lblResult.setText(self.tr("%d rows, %.1f seconds") % (model.affectedRows(), model.secs()))
cols = self.viewResult.model().columnNames()
for col in cols:
quotedCols.append(self.db.connector.quoteId(col))
except BaseError as e:
QApplication.restoreOverrideCursor()
DlgDbError.showError(e, self)
self.uniqueModel.clear()
self.geomCombo.clear()
return
self.setColumnCombos(cols, quotedCols)
self.update()
QApplication.restoreOverrideCursor()
def _getSqlLayer(self, _filter):
hasUniqueField = self.uniqueColumnCheck.checkState() == Qt.Checked
if hasUniqueField:
if self.allowMultiColumnPk:
checkedCols = []
for item in self.uniqueModel.findItems("*", Qt.MatchWildcard):
if item.checkState() == Qt.Checked:
checkedCols.append(item.data())
uniqueFieldName = ",".join(checkedCols)
elif self.uniqueCombo.currentIndex() >= 0:
uniqueFieldName = self.uniqueModel.item(self.uniqueCombo.currentIndex()).data()
else:
uniqueFieldName = None
else:
uniqueFieldName = None
hasGeomCol = self.hasGeometryCol.checkState() == Qt.Checked
if hasGeomCol:
geomFieldName = self.geomCombo.currentText()
else:
geomFieldName = None
query = self._getSqlQuery()
if query == "":
return None
# remove a trailing ';' from query if present
if query.strip().endswith(';'):
query = query.strip()[:-1]
from qgis.core import QgsMapLayer
layerType = QgsMapLayer.VectorLayer if self.vectorRadio.isChecked() else QgsMapLayer.RasterLayer
# get a new layer name
names = []
for layer in list(QgsProject.instance().mapLayers().values()):
names.append(layer.name())
layerName = self.layerNameEdit.text()
if layerName == "":
layerName = self.defaultLayerName
newLayerName = layerName
index = 1
while newLayerName in names:
index += 1
newLayerName = u"%s_%d" % (layerName, index)
# create the layer
layer = self.db.toSqlLayer(query, geomFieldName, uniqueFieldName, newLayerName, layerType,
self.avoidSelectById.isChecked(), _filter)
if layer.isValid():
return layer
else:
return None
def loadSqlLayer(self):
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
try:
layer = self._getSqlLayer(self.filter)
if layer is None:
return
QgsProject.instance().addMapLayers([layer], True)
finally:
QApplication.restoreOverrideCursor()
def fillColumnCombos(self):
query = self._getSqlQuery()
if query == "":
return
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
# remove a trailing ';' from query if present
if query.strip().endswith(';'):
query = query.strip()[:-1]
# get all the columns
cols = []
quotedCols = []
connector = self.db.connector
if self.aliasSubQuery:
# get a new alias
aliasIndex = 0
while True:
alias = "_subQuery__%d" % aliasIndex
escaped = re.compile('\\b("?)' + re.escape(alias) + '\\1\\b')
if not escaped.search(query):
break
aliasIndex += 1
sql = u"SELECT * FROM (%s\n) AS %s LIMIT 0" % (str(query), connector.quoteId(alias))
else:
sql = u"SELECT * FROM (%s\n) WHERE 1=0" % str(query)
c = None
try:
c = connector._execute(None, sql)
cols = connector._get_cursor_columns(c)
for col in cols:
quotedCols.append(connector.quoteId(col))
except BaseError as e:
QApplication.restoreOverrideCursor()
DlgDbError.showError(e, self)
self.uniqueModel.clear()
self.geomCombo.clear()
return
finally:
if c:
c.close()
del c
self.setColumnCombos(cols, quotedCols)
QApplication.restoreOverrideCursor()
def setColumnCombos(self, cols, quotedCols):
# get sensible default columns. do this before sorting in case there's hints in the column order (eg, id is more likely to be first)
try:
defaultGeomCol = next(col for col in cols if col in ['geom', 'geometry', 'the_geom', 'way'])
except:
defaultGeomCol = None
try:
defaultUniqueCol = [col for col in cols if 'id' in col][0]
except:
defaultUniqueCol = None
colNames = sorted(zip(cols, quotedCols))
newItems = []
uniqueIsFilled = False
for (col, quotedCol) in colNames:
item = QStandardItem(col)
item.setData(quotedCol)
item.setEnabled(True)
item.setCheckable(self.allowMultiColumnPk)
item.setSelectable(not self.allowMultiColumnPk)
if self.allowMultiColumnPk:
matchingItems = self.uniqueModel.findItems(col)
if matchingItems:
item.setCheckState(matchingItems[0].checkState())
uniqueIsFilled = uniqueIsFilled or matchingItems[0].checkState() == Qt.Checked
else:
item.setCheckState(Qt.Unchecked)
newItems.append(item)
if self.allowMultiColumnPk:
self.uniqueModel.clear()
self.uniqueModel.appendColumn(newItems)
self.uniqueChanged()
else:
previousUniqueColumn = self.uniqueCombo.currentText()
self.uniqueModel.clear()
self.uniqueModel.appendColumn(newItems)
if self.uniqueModel.findItems(previousUniqueColumn):
self.uniqueCombo.setEditText(previousUniqueColumn)
uniqueIsFilled = True
oldGeometryColumn = self.geomCombo.currentText()
self.geomCombo.clear()
self.geomCombo.addItems(cols)
self.geomCombo.setCurrentIndex(self.geomCombo.findText(oldGeometryColumn, Qt.MatchExactly))
# set sensible default columns if the columns are not already set
try:
if self.geomCombo.currentIndex() == -1:
self.geomCombo.setCurrentIndex(cols.index(defaultGeomCol))
except:
pass
items = self.uniqueModel.findItems(defaultUniqueCol)
if items and not uniqueIsFilled:
if self.allowMultiColumnPk:
items[0].setCheckState(Qt.Checked)
else:
self.uniqueCombo.setEditText(defaultUniqueCol)
try:
pass
except:
pass
def copySelectedResults(self):
if len(self.viewResult.selectedIndexes()) <= 0:
return
model = self.viewResult.model()
# convert to string using tab as separator
text = model.headerToString("\t")
for idx in self.viewResult.selectionModel().selectedRows():
text += "\n" + model.rowToString(idx.row(), "\t")
QApplication.clipboard().setText(text, QClipboard.Selection)
QApplication.clipboard().setText(text, QClipboard.Clipboard)
def initCompleter(self):
dictionary = None
if self.db:
dictionary = self.db.connector.getSqlDictionary()
if not dictionary:
# use the generic sql dictionary
from .sql_dictionary import getSqlDictionary
dictionary = getSqlDictionary()
wordlist = []
for name, value in list(dictionary.items()):
wordlist += value # concat lists
wordlist = list(set(wordlist)) # remove duplicates
api = QsciAPIs(self.editSql.lexer())
for word in wordlist:
api.add(word)
api.prepare()
self.editSql.lexer().setAPIs(api)
def displayQueryBuilder(self):
dlg = QueryBuilderDlg(self.iface, self.db, self, reset=self.queryBuilderFirst)
self.queryBuilderFirst = False
r = dlg.exec_()
if r == QDialog.Accepted:
self.editSql.setText(dlg.query)
def createView(self):
name, ok = QInputDialog.getText(None, "View name", "View name")
if ok:
try:
self.db.connector.createSpatialView(name, self._getSqlQuery())
except BaseError as e:
DlgDbError.showError(e, self)
def _getSqlQuery(self):
sql = self.editSql.selectedText()
if len(sql) == 0:
sql = self.editSql.text()
return sql
def uniqueChanged(self):
# when an item is (un)checked, simply trigger an update of the combobox text
self.uniqueTextChanged(None)
def uniqueTextChanged(self, text):
# Whenever there is new text displayed in the combobox, check if it is the correct one and if not, display the correct one.
checkedItems = []
for item in self.uniqueModel.findItems("*", Qt.MatchWildcard):
if item.checkState() == Qt.Checked:
checkedItems.append(item.text())
label = ", ".join(checkedItems)
if text != label:
self.uniqueCombo.setEditText(label)
def setFilter(self):
from qgis.gui import QgsQueryBuilder
layer = self._getSqlLayer("")
if not layer:
return
dlg = QgsQueryBuilder(layer)
dlg.setSql(self.filter)
if dlg.exec_():
self.filter = dlg.sql()
layer.deleteLater()
class ResourceSharingDialog(QDialog, FORM_CLASS):
TAB_ALL = 0
TAB_INSTALLED = 1
TAB_SETTINGS = 2
def __init__(self, parent=None, iface=None):
"""Constructor.
:param parent: Optional widget to use as parent
:type parent: QWidget
:param iface: An instance of QGisInterface
:type iface: QGisInterface
"""
super(ResourceSharingDialog, self).__init__(parent)
self.setupUi(self)
self.iface = iface
# Reconfigure UI
self.setModal(True)
self.button_edit.setEnabled(False)
self.button_delete.setEnabled(False)
self.button_install.setEnabled(False)
self.button_open.setEnabled(False)
self.button_uninstall.setEnabled(False)
# Set up the "main menu" - QListWidgetItem
# All collections
icon_all = QIcon()
icon_all.addFile(str(resources_path("img", "plugin.svg")), QSize(),
QIcon.Normal, QIcon.Off)
item_all = QListWidgetItem()
item_all.setIcon(icon_all)
item_all.setText(self.tr("All collections"))
# Installed collections
icon_installed = QIcon()
icon_installed.addFile(
str(resources_path("img", "plugin-installed.svg")),
QSize(),
QIcon.Normal,
QIcon.Off,
)
item_installed = QListWidgetItem()
item_installed.setIcon(icon_installed)
item_installed.setText(self.tr("Installed collections"))
item_all.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
# Settings / repositories
icon_settings = QIcon()
icon_settings.addFile(str(resources_path("img", "settings.svg")),
QSize(), QIcon.Normal, QIcon.Off)
item_settings = QListWidgetItem()
item_settings.setIcon(icon_settings)
item_settings.setText(self.tr("Settings"))
item_all.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
# Add the items to the list widget
self.menu_list_widget.addItem(item_all)
self.menu_list_widget.addItem(item_installed)
self.menu_list_widget.addItem(item_settings)
# Init the message bar
self.message_bar = QgsMessageBar(self)
self.message_bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.vlayoutRightColumn.insertWidget(0, self.message_bar)
# Progress dialog for long running processes
self.progress_dialog = None
# Init the repository manager dialog
self.repository_manager = RepositoryManager()
self.collection_manager = CollectionManager()
# Collections list view
self.collections_model = QStandardItemModel(0, 1)
self.collections_model.sort(0, Qt.AscendingOrder)
self.collection_proxy = CustomSortFilterProxyModel(self)
self.collection_proxy.setSourceModel(self.collections_model)
self.list_view_collections.setModel(self.collection_proxy)
# Active selected collection
self._sel_coll_id = None
# Slots
self.button_add.clicked.connect(self.add_repository)
self.button_edit.clicked.connect(self.edit_repository)
self.button_delete.clicked.connect(self.delete_repository)
self.button_reload.clicked.connect(self.reload_repositories)
self.button_reload_dir.clicked.connect(self.reload_off_res_directory)
self.menu_list_widget.currentRowChanged.connect(self.set_current_tab)
self.list_view_collections.selectionModel().currentChanged.connect(
self.on_list_view_collections_clicked)
self.line_edit_filter.textChanged.connect(self.filter_collections)
self.button_install.clicked.connect(self.install_collection)
self.button_open.clicked.connect(self.open_collection)
self.button_uninstall.clicked.connect(self.uninstall_collection)
self.button_box.button(QDialogButtonBox.Help).clicked.connect(
self.open_help)
# Populate the repositories widget and collections list view
self.populate_repositories_widget()
self.reload_collections_model()
def set_current_tab(self, index):
"""Set stacked widget based on the active tab.
:param index: The index of the active widget (in the list widget).
:type index: int
"""
# Clear message bar
self.message_bar.clearWidgets()
if index == (self.menu_list_widget.count() - 1):
# Last menu entry - Settings
self.stacked_menu_widget.setCurrentIndex(1)
else:
# Not settings, must be Collections (all or installed)
if index == 1:
# Installed collections
self.collection_proxy.accepted_status = COLLECTION_INSTALLED_STATUS
# Set the web view
title = self.tr("Installed Collections")
description = self.tr(
"On the left you see the list of all the "
"installed collections.")
else:
# All collections (0)
self.collection_proxy.accepted_status = COLLECTION_ALL_STATUS
# Set the web view
title = self.tr("All Collections")
description = self.tr(
"On the left you see a list of all the collections "
"that are available from the registered repositories.<br> "
"Installed collections are emphasized (in <b>bold</b>).")
context = {
"resources_path": str(resources_path()),
"title": title,
"description": description,
}
self.web_view_details.setHtml(
render_template("tab_description.html", context))
self.stacked_menu_widget.setCurrentIndex(0)
def add_repository(self):
"""Open add repository dialog."""
dlg = ManageRepositoryDialog(self)
if not dlg.exec_():
return
for repoName, repo in self.repository_manager.directories.items():
if dlg.line_edit_url.text().strip() == repo["url"]:
self.message_bar.pushMessage(
self.tr(
"Unable to add another repository with the same URL!"),
Qgis.Warning,
5,
)
return
if dlg.line_edit_name.text().strip() == repoName:
self.message_bar.pushMessage(
self.tr("Repositories must have unique names!"),
Qgis.Warning, 5)
return
repo_name = dlg.line_edit_name.text()
repo_url = dlg.line_edit_url.text().strip()
repo_auth_cfg = dlg.line_edit_auth_id.text().strip()
if repo_name in self.repository_manager.directories:
repo_name += "(2)"
# Show progress dialog
self.show_progress_dialog("Fetching repository's metadata")
# Add repository
try:
status, adderror = self.repository_manager.add_directory(
repo_name, repo_url, repo_auth_cfg)
if status:
self.message_bar.pushMessage(
self.tr("Repository was successfully added"), Qgis.Success,
5)
else:
self.message_bar.pushMessage(
self.tr("Unable to add repository: %s") % adderror,
Qgis.Warning, 5)
except Exception as e:
self.message_bar.pushMessage(self.tr("%s") % e, Qgis.Warning, 5)
finally:
self.progress_dialog.hide()
# Reload data and widget
self.reload_data_and_widget()
# Deactivate edit and delete button
self.button_edit.setEnabled(False)
self.button_delete.setEnabled(False)
def edit_repository(self):
"""Open edit repository dialog."""
selected_item = self.tree_repositories.currentItem()
if selected_item:
repo_name = selected_item.text(0)
if not repo_name:
return
# Check if it is among the officially approved QGIS repositories
settings = QgsSettings()
settings.beginGroup(repo_settings_group())
if (settings.value(repo_name + "/url")
in self.repository_manager._online_directories.values()):
self.message_bar.pushMessage(
self.tr("You can not edit the official repositories!"),
Qgis.Warning, 5)
return
dlg = ManageRepositoryDialog(self)
dlg.line_edit_name.setText(repo_name)
dlg.line_edit_url.setText(
self.repository_manager.directories[repo_name]["url"])
dlg.line_edit_auth_id.setText(
self.repository_manager.directories[repo_name]["auth_cfg"])
if not dlg.exec_():
return
# Check if the changed URL is already present and that
# the new repository name is unique
new_url = dlg.line_edit_url.text().strip()
old_url = self.repository_manager.directories[repo_name]["url"]
new_name = dlg.line_edit_name.text().strip()
for repoName, repo in self.repository_manager.directories.items():
if new_url == repo["url"] and (old_url != new_url):
self.message_bar.pushMessage(
self.tr("Unable to add another repository with the same "
"URL!"),
Qgis.Warning,
5,
)
return
if new_name == repoName and (repo_name != new_name):
self.message_bar.pushMessage(
self.tr("Repositories must have unique names!"),
Qgis.Warning, 5)
return
# Redundant
if (new_name in self.repository_manager.directories) and (new_name !=
repo_name):
new_name += "(2)"
new_auth_cfg = dlg.line_edit_auth_id.text()
# Show progress dialog
self.show_progress_dialog("Fetching repository's metadata")
# Edit repository
try:
status, editerror = self.repository_manager.edit_directory(
repo_name, new_name, old_url, new_url, new_auth_cfg)
if status:
self.message_bar.pushMessage(
self.tr("Repository is successfully updated"),
Qgis.Success, 5)
else:
self.message_bar.pushMessage(
self.tr("Unable to edit repository: %s") % editerror,
Qgis.Warning,
5,
)
except Exception as e:
self.message_bar.pushMessage(self.tr("%s") % e, Qgis.Warning, 5)
finally:
self.progress_dialog.hide()
# Reload data and widget
self.reload_data_and_widget()
# Deactivate the edit and delete buttons
self.button_edit.setEnabled(False)
self.button_delete.setEnabled(False)
def delete_repository(self):
"""Delete a repository in the tree widget."""
selected_item = self.tree_repositories.currentItem()
if selected_item:
repo_name = selected_item.text(0)
if not repo_name:
return
# Check if it is among the offical repositories
repo_url = self.repository_manager.directories[repo_name]["url"]
if repo_url in self.repository_manager._online_directories.values():
self.message_bar.pushMessage(
self.tr("You can not remove official repositories!"),
Qgis.Warning, 5)
return
warning = (self.tr("Are you sure you want to remove the following "
"repository?") + "\n" + repo_name)
if (QMessageBox.warning(
self,
self.tr("QGIS Resource Sharing"),
warning,
QMessageBox.Yes,
QMessageBox.No,
) == QMessageBox.No):
return
# Remove repository
installed_collections = self.collection_manager.get_installed_collections(
repo_url)
if installed_collections:
message = ("You have installed collections from this "
"repository. Please uninstall them first!")
self.message_bar.pushMessage(message, Qgis.Warning, 5)
else:
self.repository_manager.remove_directory(repo_name)
# Reload data and widget
self.reload_data_and_widget()
# Deactivate the edit and delete buttons
self.button_edit.setEnabled(False)
self.button_delete.setEnabled(False)
def reload_off_res_directory(self):
"""Slot called when the user clicks the 'Reload directory'
button."""
# Show progress dialog
self.show_progress_dialog("Reloading the official QGIS resource"
" directory")
self.repository_manager._online_directories = {}
# Registered directories
self.repository_manager._directories = {}
self.repository_manager.fetch_online_directories()
# Load directory of repositories from settings
self.repository_manager.load_directories()
self.message_bar.pushMessage("On-line directory reloaded", Qgis.Info,
5)
self.progress_dialog.hide()
# Reload data and widget
self.reload_data_and_widget()
def reload_repositories(self):
"""Slot called when the user clicks the 'Reload repositories'
button."""
# Show progress dialog
self.show_progress_dialog("Reloading all repositories")
for repo_name in self.repository_manager.directories:
directory = self.repository_manager.directories[repo_name]
url = directory["url"]
auth_cfg = directory["auth_cfg"]
try:
status, reloaderror = self.repository_manager.reload_directory(
repo_name, url, auth_cfg)
if status:
self.message_bar.pushMessage(
self.tr("Repository %s is successfully reloaded") %
repo_name,
Qgis.Info,
5,
)
else:
self.message_bar.pushMessage(
self.tr("Unable to reload %s: %s") %
(repo_name, reloaderror),
Qgis.Warning,
5,
)
except Exception as e:
self.message_bar.pushMessage(
self.tr("%s") % e, Qgis.Warning, 5)
self.progress_dialog.hide()
# Reload data and widget
self.reload_data_and_widget()
def install_collection(self):
"""Slot called when the user clicks the Install/Reinstall button."""
# Save the current index to enable selection after installation
self.current_index = self.list_view_collections.currentIndex()
self.show_progress_dialog("Starting installation...")
self.progress_dialog.canceled.connect(self.install_canceled)
self.installer_thread = QThread()
self.installer_worker = CollectionInstaller(self.collection_manager,
self._sel_coll_id)
self.installer_worker.moveToThread(self.installer_thread)
self.installer_worker.finished.connect(self.install_finished)
self.installer_worker.aborted.connect(self.install_aborted)
self.installer_worker.progress.connect(self.install_progress)
self.installer_thread.started.connect(self.installer_worker.run)
self.installer_thread.start()
def install_finished(self):
# Process the result
self.progress_dialog.hide()
installStatus = self.installer_worker.install_status
if not installStatus:
message = self.installer_worker.error_message
# Clean up the worker and thread
self.installer_worker.deleteLater()
self.installer_thread.quit()
self.installer_thread.wait()
self.installer_thread.deleteLater()
if installStatus:
self.reload_collections_model()
# Report what has been installed
message = "<b>%s</b> was successfully installed, " "containing:\n<ul>" % (
config.COLLECTIONS[self._sel_coll_id]["name"])
number = 0
for type_, description in SUPPORTED_RESOURCES_MAP.items():
if type_ in config.COLLECTIONS[self._sel_coll_id].keys():
number = config.COLLECTIONS[self._sel_coll_id][type_]
message += (f"\n<li>{number} {description}"
f'{"s" if number > 1 else ""}'
f"</li>")
message += "\n</ul>"
QMessageBox.information(self, "Resource Sharing", message)
self.populate_repositories_widget()
# Set the selection
oldRow = self.current_index.row()
newIndex = self.collections_model.createIndex(oldRow, 0)
selection_model = self.list_view_collections.selectionModel()
selection_model.setCurrentIndex(newIndex,
selection_model.ClearAndSelect)
selection_model.select(newIndex, selection_model.ClearAndSelect)
# Update the buttons
self.button_install.setEnabled(True)
self.button_install.setText("Reinstall")
self.button_open.setEnabled(True)
self.button_uninstall.setEnabled(True)
self.show_collection_metadata(self._sel_coll_id)
def install_canceled(self):
self.progress_dialog.hide()
self.show_progress_dialog("Cancelling installation...")
self.installer_worker.abort()
def install_aborted(self):
if self.installer_thread.isRunning():
self.installer_thread.quit()
self.installer_thread.finished.connect(self.progress_dialog.hide)
def install_progress(self, text):
self.progress_dialog.setLabelText(text)
def uninstall_collection(self):
"""Slot called when the user clicks the 'Uninstall' button."""
# get the QModelIndex for the item to be uninstalled
uninstall_index = self.list_view_collections.currentIndex()
coll_id = self._sel_coll_id
try:
self.collection_manager.uninstall(coll_id)
except Exception as e:
LOGGER.error("Could not uninstall collection " +
config.COLLECTIONS[coll_id]["name"] + ":\n" + str(e))
else:
QMessageBox.information(
self, "Resource Sharing",
"The collection was successfully uninstalled!")
self.reload_collections_model()
# Fix the GUI
currentMenuRow = self.menu_list_widget.currentRow()
self.set_current_tab(currentMenuRow)
self.populate_repositories_widget()
rowCount = self.collection_proxy.rowCount()
if rowCount > 0:
# Set the current (and selected) row in the listview
newRow = uninstall_index.row()
# Check if this was the last element
rowCount = self.collection_proxy.rowCount()
if newRow == rowCount:
newRow = newRow - 1
# Select the new current element
newIndex = self.collections_model.createIndex(newRow, 0)
selection_model = self.list_view_collections.selectionModel()
selection_model.setCurrentIndex(newIndex,
selection_model.ClearAndSelect)
# Get the id of the current collection
proxyModel = self.list_view_collections.model()
proxyIndex = proxyModel.index(newRow, 0)
current_coll_id = proxyIndex.data(COLLECTION_ID_ROLE)
self._sel_coll_id = current_coll_id
# Update buttons
status = config.COLLECTIONS[current_coll_id]["status"]
if status == COLLECTION_INSTALLED_STATUS:
self.button_install.setEnabled(True)
self.button_install.setText("Reinstall")
self.button_open.setEnabled(True)
self.button_uninstall.setEnabled(True)
else:
self.button_install.setEnabled(True)
self.button_install.setText("Install")
self.button_open.setEnabled(False)
self.button_uninstall.setEnabled(False)
# Update the web_view_details frame
self.show_collection_metadata(current_coll_id)
else:
self.button_install.setEnabled(False)
self.button_install.setText("Install")
self.button_open.setEnabled(False)
self.button_uninstall.setEnabled(False)
def open_collection(self):
"""Slot called when the user clicks the 'Open' button."""
collection_path = local_collection_path(self._sel_coll_id)
directory_url = QUrl.fromLocalFile(str(collection_path))
QDesktopServices.openUrl(directory_url)
def reload_data_and_widget(self):
"""Reload repositories and collections and update widgets related."""
self.reload_repositories_widget()
self.reload_collections_model()
def reload_repositories_widget(self):
"""Refresh tree repositories using new repositories data."""
self.repository_manager.load_directories()
self.populate_repositories_widget()
def populate_repositories_widget(self):
"""Populate the current dictionary repositories to the tree widget."""
# Clear the current tree widget
self.tree_repositories.clear()
installed_collections = self.collection_manager.get_installed_collections(
)
# Export the updated ones from the repository manager
repo_Font = QFont()
repo_with_installed_Font = QFont()
repo_with_installed_Font.setWeight(60)
collection_brush = QBrush(Qt.darkGray)
installed_collection_brush = QBrush(QColor(60, 25, 10))
for repo_name in self.repository_manager.directories:
url = self.repository_manager.directories[repo_name]["url"]
item = QTreeWidgetItem(self.tree_repositories, REPOSITORY_ITEM)
# Is the repository in the QGIS resource directory?
if url in self.repository_manager._online_directories.values():
repo_with_installed_Font.setUnderline(True)
repo_Font.setUnderline(True)
else:
repo_with_installed_Font.setUnderline(False)
repo_Font.setUnderline(False)
item.setText(0, repo_name)
item.setText(1, url)
item.setFont(0, repo_Font)
for coll_id in config.COLLECTIONS:
if ("repository_name" in config.COLLECTIONS[coll_id].keys()
and config.COLLECTIONS[coll_id]["repository_name"]
== repo_name):
coll_name = config.COLLECTIONS[coll_id]["name"]
coll_tags = config.COLLECTIONS[coll_id]["tags"]
collectionItem = QTreeWidgetItem(item, COLLECTION_ITEM)
brush = collection_brush
collectionFont = QFont()
collectionFont.setStyle(QFont.StyleItalic)
collitemtext = coll_name
if (installed_collections
and coll_id in installed_collections.keys()):
collitemtext = coll_name + " (installed)"
brush = installed_collection_brush
item.setFont(0, repo_with_installed_Font)
item.setForeground(0, brush)
item.setForeground(1, brush)
collectionItem.setFont(0, collectionFont)
collectionItem.setForeground(0, brush)
collectionItem.setText(0, collitemtext)
collectionItem.setFont(1, collectionFont)
collectionItem.setForeground(1, brush)
collectionItem.setText(1, coll_tags)
self.tree_repositories.resizeColumnToContents(0)
self.tree_repositories.resizeColumnToContents(1)
self.tree_repositories.sortItems(1, Qt.AscendingOrder)
def reload_collections_model(self):
"""Reload the collections model with the current collections."""
self.collections_model.clear()
installed_collections = self.collection_manager.get_installed_collections(
)
for id in config.COLLECTIONS:
collection_name = config.COLLECTIONS[id]["name"]
collection_author = config.COLLECTIONS[id]["author"]
collection_tags = config.COLLECTIONS[id]["tags"]
collection_description = config.COLLECTIONS[id]["description"]
collection_status = config.COLLECTIONS[id]["status"]
repository_name = ""
if "repository_name" in config.COLLECTIONS[id].keys():
repository_name = config.COLLECTIONS[id]["repository_name"]
item = QStandardItem(collection_name + " (" + repository_name +
")")
item.setEditable(False)
item.setData(id, COLLECTION_ID_ROLE)
item.setData(collection_name, COLLECTION_NAME_ROLE)
item.setData(collection_description, COLLECTION_DESCRIPTION_ROLE)
item.setData(collection_author, COLLECTION_AUTHOR_ROLE)
item.setData(collection_tags, COLLECTION_TAGS_ROLE)
item.setData(collection_status, COLLECTION_STATUS_ROLE)
# Make installed collections stand out
if installed_collections and id in installed_collections.keys():
collectionFont = QFont()
collectionFont.setWeight(60)
item.setFont(collectionFont)
self.collections_model.appendRow(item)
self.collections_model.sort(0, Qt.AscendingOrder)
def on_tree_repositories_itemSelectionChanged(self):
"""Slot for the itemSelectionChanged signal of tree_repositories."""
selected_item = self.tree_repositories.currentItem()
if selected_item and selected_item.type() == REPOSITORY_ITEM:
if selected_item:
repo_name = selected_item.text(0)
if not repo_name:
return
if repo_name not in self.repository_manager.directories.keys():
return
repo_url = self.repository_manager.directories[repo_name]["url"]
# Disable the edit and delete buttons for "official" repositories
if repo_url in self.repository_manager._online_directories.values(
):
self.button_edit.setEnabled(False)
self.button_delete.setEnabled(False)
else:
# Activate the edit and delete buttons
self.button_edit.setEnabled(True)
self.button_delete.setEnabled(True)
elif selected_item and selected_item.type() == COLLECTION_ITEM:
self.button_edit.setEnabled(False)
self.button_delete.setEnabled(False)
else:
self.button_edit.setEnabled(False)
self.button_delete.setEnabled(False)
def on_list_view_collections_clicked(self, index):
"""Slot called when the user clicks an item in
list_view_collections."""
real_index = self.collection_proxy.mapToSource(index)
if real_index.row() != -1:
collection_item = self.collections_model.itemFromIndex(real_index)
collection_id = collection_item.data(COLLECTION_ID_ROLE)
self._sel_coll_id = collection_id
# Enable / disable buttons
status = config.COLLECTIONS[self._sel_coll_id]["status"]
is_installed = status == COLLECTION_INSTALLED_STATUS
if is_installed:
self.button_install.setEnabled(True)
self.button_install.setText("Reinstall")
self.button_open.setEnabled(True)
self.button_uninstall.setEnabled(True)
else:
self.button_install.setEnabled(True)
self.button_install.setText("Install")
self.button_open.setEnabled(False)
self.button_uninstall.setEnabled(False)
# Show metadata
self.show_collection_metadata(collection_id)
@pyqtSlot(str)
def filter_collections(self, text):
search = QRegExp(text, Qt.CaseInsensitive, QRegExp.RegExp)
self.collection_proxy.setFilterRegExp(search)
def show_collection_metadata(self, id):
"""Show the collection metadata given the ID."""
html = self.collection_manager.get_html(id)
self.web_view_details.setHtml(html)
def reject(self):
"""Slot called when the dialog is closed."""
# Serialize collections to settings
self.repository_manager.serialize_repositories()
self.done(0)
def open_help(self):
"""Open help."""
doc_url = QUrl("http://qgis-contribution.github.io/" +
"QGIS-ResourceSharing/")
QDesktopServices.openUrl(doc_url)
def show_progress_dialog(self, text):
"""Show infinite progress dialog with given text.
:param text: Text as the label of the progress dialog
:type text: str
"""
if self.progress_dialog is None:
self.progress_dialog = QProgressDialog(self)
self.progress_dialog.setWindowModality(Qt.WindowModal)
self.progress_dialog.setAutoClose(False)
title = self.tr("Resource Sharing")
self.progress_dialog.setWindowTitle(title)
# Just use an infinite progress bar here
self.progress_dialog.setMaximum(0)
self.progress_dialog.setMinimum(0)
self.progress_dialog.setValue(0)
self.progress_dialog.setLabelText(text)
self.progress_dialog.show()
class ListWidget(EditorWidget):
widgettype = 'List'
def __init__(self, *args, **kwargs):
super(ListWidget, self).__init__(*args, **kwargs)
self.listmodel = QStandardItemModel()
self._bindvalue = None
def createWidget(self, parent):
return QComboBox(parent)
def _buildfromlist(self, widget, listconfig):
items = listconfig['items']
for item in items:
parts = item.split(';')
data = parts[0]
try:
desc = parts[1]
except IndexError:
desc = data
try:
path = parts[2]
path = path.strip()
icon = QIcon(path)
except:
icon = QIcon()
item = QStandardItem(desc)
item.setData(data, Qt.UserRole)
item.setIcon(icon)
self.listmodel.appendRow(item)
def _buildfromlayer(self, widget, layerconfig):
layername = layerconfig['layer']
keyfield = layerconfig['key']
valuefield = layerconfig['value']
filterexp = layerconfig.get('filter', None)
try:
layer = utils.layer_by_name(layername)
except IndexError:
roam.utils.warning(
"Can't find layer {} in project".format(layername))
return
keyfieldindex = layer.fields().lookupField(keyfield)
valuefieldindex = layer.fields().lookupField(valuefield)
if keyfieldindex == -1 or valuefieldindex == -1:
roam.utils.warning(f"Can't find key or value column for widget "
f"Id: {self.id} "
f"Layer: {layername} "
f"Key: {keyfield} - {keyfieldindex} "
f"Value: {valuefield} - {valuefieldindex} ")
return
if self.allownulls:
item = QStandardItem('(no selection)')
item.setData(None, Qt.UserRole)
self.listmodel.appendRow(item)
fields = [keyfieldindex, valuefieldindex]
iconfieldindex = layer.fields().lookupField('icon')
if iconfieldindex > -1:
fields.append("icon")
if not filterexp and valuefieldindex == keyfieldindex and iconfieldindex == -1:
values = layer.uniqueValues(keyfieldindex)
values = sorted(values)
for value in values:
value = nullconvert(value)
item = QStandardItem(value)
item.setData(value, Qt.UserRole)
self.listmodel.appendRow(item)
return
features = roam.api.utils.search_layer(layer,
filterexp,
fields,
with_geometry=False)
# Sort the fields based on value field
features = sorted(features, key=lambda f: f[keyfield])
for feature in features:
keyvalue = nullconvert(feature[keyfieldindex])
valuvalue = nullconvert(feature[valuefield])
try:
path = feature["icon"]
icon = QIcon(path)
except KeyError:
icon = QIcon()
item = QStandardItem(keyvalue)
item.setData(str(valuvalue), Qt.UserRole)
item.setIcon(icon)
self.listmodel.appendRow(item)
def initWidget(self, widget, config):
if widget.isEditable():
widget.editTextChanged.connect(self.emitvaluechanged)
widget.currentIndexChanged.connect(self.emitvaluechanged)
widget.setModel(self.listmodel)
widget.showPopup = self.showpopup
widget.setIconSize(QSize(24, 24))
widget.setStyleSheet(
"QComboBox::drop-down {border-width: 0px;} QComboBox::down-arrow {image: url(noimg); border-width: 0px;}"
)
widget.setSizeAdjustPolicy(QComboBox.AdjustToMinimumContentsLength)
def showpopup(self):
if self.listmodel.rowCount() == 0:
return
self.largewidgetrequest.emit(
BigListWidget, self.widget.currentIndex(), self._biglistitem,
dict(model=self.listmodel, label=self.labeltext))
def updatefromconfig(self):
super(ListWidget, self).updatefromconfig()
self.listmodel.clear()
if 'list' in self.config:
listconfig = self.config['list']
self._buildfromlist(self.widget, listconfig)
elif 'layer' in self.config:
layerconfig = self.config['layer']
self._buildfromlayer(self.widget, layerconfig)
super(ListWidget, self).endupdatefromconfig()
@property
def allownulls(self):
return self.config.get('allownull', False)
def validate(self, *args):
if (not self.widget.currentText() == ''
and not self.widget.currentText() == "(no selection)"):
return True
else:
return False
def _biglistitem(self, index):
self.widget.setCurrentIndex(index.row())
def setvalue(self, value):
self._bindvalue = value
index = self.widget.findData(value)
self.widget.setCurrentIndex(index)
if index == -1 and self.widget.isEditable():
if value is None and not self.config['allownull']:
return
self.widget.addItem(str(value))
index = self.widget.count() - 1
self.widget.setCurrentIndex(index)
def value(self):
index = self.widget.currentIndex()
value = self.widget.itemData(index)
text = self.widget.currentText()
if value is None and self.widget.isEditable(
) and not text == '(no selection)':
return self.widget.currentText()
return value
class ThinGreyscaleDialog(QDialog, FORM_CLASS):
def __init__(self, iface, parent=None):
"""Constructor."""
self.iface = iface
self.plugin_dir = dirname(__file__)
self.THINGREYSCALE = self.tr('ThinGreyscale')
self.BROWSE = self.tr('Browse')
self.CANCEL = self.tr('Cancel')
self.CLOSE = self.tr('Close')
self.HELP = self.tr('Help')
self.OK = self.tr('OK')
self.DEFAULTPROVIDER = 'GTiff'
self.DEFAULTEXTENSION = '.tif'
self.EXTRAEXTENSION = ' *.tiff'
super(ThinGreyscaleDialog, self).__init__(parent)
# Set up the user interface from Designer.
# After setupUI you can access any designer object by doing
# self.<objectname>, and you can use autoconnect slots - see
# http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html
# #widgets-and-dialogs-with-auto-connect
self.setupUi(self)
self.showInfo("Connecting UI components")
okButton = self.button_box.button(QDialogButtonBox.Ok)
okButton.setText(self.OK)
cancelButton = self.button_box.button(QDialogButtonBox.Cancel)
cancelButton.setText(self.CANCEL)
cancelButton.setEnabled(False)
closeButton = self.button_box.button(QDialogButtonBox.Close)
closeButton.setText(self.CLOSE)
browseButton = self.browseButton
browseButton.setText(self.BROWSE)
self.calcHistPushButton.setEnabled(False)
self.listModel = QStandardItemModel(self.levelsListView)
self.levelsListView.setModel(self.listModel)
self.levelsListView.sizeHintForColumn(20)
#self.levelValuesCheckBox.setEnabled(False)
# Help button
helpButton = self.helpButton
helpButton.setText(self.HELP)
# Connect signals
self.showInfo("Connecting signals")
okButton.clicked.connect(self.startWorker)
cancelButton.clicked.connect(self.killWorker)
closeButton.clicked.connect(self.reject)
helpButton.clicked.connect(self.help)
browseButton.clicked.connect(self.browse)
inpIndexCh = self.inputRaster.currentIndexChanged['QString']
inpIndexCh.connect(self.layerchanged)
bandCh = self.bandComboBox.currentIndexChanged['QString']
bandCh.connect(self.bandChanged)
#self.iface.legendInterface().itemAdded.connect(
# self.layerlistchanged)
#self.iface.legendInterface().itemRemoved.connect(
# self.layerlistchanged)
#QObject.disconnect(self.button_box, SIGNAL("rejected()"), self.reject)
self.button_box.rejected.disconnect(self.reject)
calchistPr = self.calcHistPushButton.clicked
calchistPr.connect(self.calculateHistogram)
sugglevPr = self.suggestlevelsPushButton.clicked
sugglevPr.connect(self.suggestLevels)
addlevPr = self.addlevelPushButton.clicked
addlevPr.connect(self.addLevel)
dellevPr = self.deletelevelsPushButton.clicked
dellevPr.connect(self.removeLevel)
maxvalCh = self.maxValueSpinBox.valueChanged
maxvalCh.connect(self.minmaxvalueChanged)
maxvalFi = self.maxValueSpinBox.editingFinished
maxvalFi.connect(self.minmaxvalueEdFinished)
minvalCh = self.minValueSpinBox.valueChanged
minvalCh.connect(self.minmaxvalueChanged)
minvalFi = self.minValueSpinBox.editingFinished
minvalFi.connect(self.minmaxvalueEdFinished)
# Set instance variables
#self.mem_layer = None
self.worker = None
self.inputlayerid = None
self.inputlayer = None
self.layerlistchanging = False
self.minvalue = 1
self.inputrasterprovider = None
self.histobins = 50
self.setupScene = QGraphicsScene(self)
self.histoGraphicsView.setScene(self.setupScene)
# Is the layer band of an integer type
self.intband = False
self.histogramAvailable = False
self.histo = None
self.histopadding = 1
def startWorker(self):
"""Initialises and starts the worker thread."""
try:
layerindex = self.inputRaster.currentIndex()
layerId = self.inputRaster.itemData(layerindex)
inputlayer = QgsProject.instance().mapLayer(layerId)
#inputlayer = QgsMapLayerRegistry.instance().mapLayer(layerId)
if inputlayer is None:
self.showError(self.tr('No input layer defined'))
return
# create a reference to the layer that is being processed
# (for use when creating the resulting raster layer)
self.thinninglayer = inputlayer
self.levels = []
#self.levelsListView.selectAll()
#selected = self.levelsListView.selectedIndexes()
if self.levelsListView.model().rowCount() == 0:
self.showInfo("Levels must be specified!")
return
for i in range(self.levelsListView.model().rowCount()):
levelstring = self.levelsListView.model().item(i).text()
#for i in selected:
# levelstring = self.levelsListView.model().itemData(i)[0]
if self.intband:
self.levels.append(int(levelstring))
else:
self.levels.append(float(levelstring))
#self.levelsListView.clearSelection()
# create a new worker instance
worker = Worker(inputlayer, self.levels, self.intband)
# configure the QgsMessageBar
msgBar = self.iface.messageBar().createMessage(
self.tr('Skeletonising'), '')
self.aprogressBar = QProgressBar()
self.aprogressBar.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
acancelButton = QPushButton()
acancelButton.setText(self.CANCEL)
acancelButton.clicked.connect(self.killWorker)
msgBar.layout().addWidget(self.aprogressBar)
msgBar.layout().addWidget(acancelButton)
# Has to be popped after the thread has finished (in
# workerFinished).
self.iface.messageBar().pushWidget(msgBar, Qgis.Info)
self.messageBar = msgBar
# start the worker in a new thread
thread = QThread(self)
worker.moveToThread(thread)
worker.finished.connect(self.workerFinished)
worker.error.connect(self.workerError)
worker.status.connect(self.workerInfo)
worker.progress.connect(self.progressBar.setValue)
worker.progress.connect(self.aprogressBar.setValue)
worker.iterprogress.connect(self.iterProgressBar.setValue)
thread.started.connect(worker.run)
thread.start()
self.thread = thread
self.worker = worker
self.button_box.button(QDialogButtonBox.Ok).setEnabled(False)
self.button_box.button(QDialogButtonBox.Close).setEnabled(False)
self.button_box.button(QDialogButtonBox.Cancel).setEnabled(True)
except:
import traceback
self.showError(traceback.format_exc())
else:
pass
def workerFinished(self, ok, ret):
"""Handles the output from the worker and cleans up after the
worker has finished."""
# clean up the worker and thread
self.showInfo("Handling the result")
self.worker.deleteLater()
self.thread.quit()
self.thread.wait()
self.thread.deleteLater()
# remove widget from message bar (pop)
self.iface.messageBar().popWidget(self.messageBar)
if ok and ret is not None:
#self.showInfo("Ret: "+str(ret[10,]))
# Transformation:
self.minx = self.thinninglayer.extent().xMinimum()
self.maxx = self.thinninglayer.extent().xMaximum()
self.miny = self.thinninglayer.extent().yMinimum()
self.maxy = self.thinninglayer.extent().yMaximum()
self.rows = self.thinninglayer.height()
self.cols = self.thinninglayer.width()
self.xres = (self.maxx - self.minx) / float(self.cols)
self.yres = (self.maxy - self.miny) / float(self.rows)
geotransform = (self.minx, self.xres, 0, self.maxy, 0, -self.yres)
try:
format = self.DEFAULTPROVIDER
driver = gdal.GetDriverByName(format)
NOVALUE = 0
metadata = driver.GetMetadata()
fileName = self.outputRaster.text()
if self.outputRaster.text() == "":
self.showInfo("No output file specified, " +
"creating a temporary file")
# Get a temporary file
fileName = mktemp(prefix='greyskel',
suffix=self.DEFAULTEXTENSION)
fileInfo = QFileInfo(fileName)
filepath = fileInfo.absolutePath()
baseName = fileInfo.baseName()
suffix = fileInfo.suffix()
thisfilename = filepath + baseName + '.' + suffix
thisfilename = fileName
self.showInfo("File name: " + thisfilename)
gdaldatatype = gdal.GDT_Byte
skelmatrix = None
if self.levelValuesCheckBox.isChecked():
# Transform the pixel values back to the original
# level values
my_dict = {}
# Add zero to handle the "empty" pixels
my_dict[0] = 0
for i in range(len(self.levels)):
my_dict[i + 1] = self.levels[i]
skelmatrix = np.vectorize(my_dict.__getitem__,
otypes=[np.float])(ret)
gdaldatatype = gdal.GDT_Int32
if not self.intband:
gdaldatatype = gdal.GDT_Float32
else:
skelmatrix = ret
outDataset = driver.Create(thisfilename, self.cols, self.rows,
1, gdaldatatype)
if self.thinninglayer.dataProvider().crs() is not None:
srs = self.thinninglayer.dataProvider().crs()
outDataset.SetProjection(srs.toWkt().encode(
'ascii', 'ignore'))
skeletonband = outDataset.GetRasterBand(1)
skeletonband.WriteArray(skelmatrix)
skeletonband.SetNoDataValue(NOVALUE)
#stats = skeletonband.GetStatistics(False, True)
#skeletonband.SetStatistics(stats[0], stats[1],
# stats[2], stats[3])
outDataset.SetGeoTransform(geotransform)
outDataset = None # To close the file
# report the result
rlayer = QgsRasterLayer(thisfilename, baseName)
self.layerlistchanging = True
#QgsMapLayerRegistry.instance().addMapLayer(rlayer)
QgsProject.instance().addMapLayer(rlayer)
self.layerlistchanging = False
except:
import traceback
self.showError("Can't write the skeleton file: %s" %
self.outputRaster.text() + ' - ' +
traceback.format_exc())
okb = self.button_box.button(QDialogButtonBox.Ok)
okb.setEnabled(True)
closb = self.button_box.button(QDialogButtonBox.Close)
closb.setEnabled(True)
cancb = self.button_box.button(QDialogButtonBox.Cancel)
cancb.setEnabled(False)
return
QgsMessageLog.logMessage(self.tr('ThinGreyscale finished'),
self.THINGREYSCALE, Qgis.Info)
else:
# notify the user that something went wrong
if not ok:
self.showError(self.tr('Aborted') + '!')
else:
self.showError(self.tr('No skeleton created') + '!')
self.progressBar.setValue(0.0)
#self.aprogressBar.setValue(0.0)
self.iterProgressBar.setValue(0.0)
self.button_box.button(QDialogButtonBox.Ok).setEnabled(True)
self.button_box.button(QDialogButtonBox.Close).setEnabled(True)
self.button_box.button(QDialogButtonBox.Cancel).setEnabled(False)
def workerError(self, exception_string):
"""Report an error from the worker."""
#QgsMessageLog.logMessage(self.tr('Worker failed - exception') +
# ': ' + str(exception_string),
# self.THINGREYSCALE,
# QgsMessageLog.CRITICAL)
self.showError(exception_string)
def workerInfo(self, message_string):
"""Report an info message from the worker."""
QgsMessageLog.logMessage(
self.tr('Worker') + ': ' + message_string, self.THINGREYSCALE,
Qgis.Info)
def layerchanged(self, number=0):
"""Do the necessary updates after a layer selection has
been changed."""
self.showInfo("Layer changed")
# If the layer list is being updated, don't do anything
if self.layerlistchanging:
return
layerindex = self.inputRaster.currentIndex()
layerId = self.inputRaster.itemData(layerindex)
self.inputlayerid = layerId
#self.inputlayer = QgsMapLayerRegistry.instance().mapLayer(layerId)
self.inputlayer = QgsProject.instance().mapLayer(layerId)
if self.inputlayer is not None:
self.inputrasterprovider = self.inputlayer.dataProvider()
self.bandComboBox.clear()
bandcount = self.inputlayer.bandCount()
#self.showInfo("Layer bandcount: "+str(bandcount))
for i in range(bandcount):
self.bandComboBox.addItem(self.inputlayer.bandName(i + 1), i)
#self.showInfo("Band " + str(i) + ": " +
# self.inputlayer.bandName(i+1))
# Check if the driver supports Create() or CreateCopy()
#gdalmetadata = self.inputlayer.metadata()
#self.showInfo("Layer metadata: " +
# str(gdalmetadata.encode('utf-8')))
#provstring = '<p>GDAL provider</p>\n'
#providerpos = gdalmetadata.find(provstring)
#brpos = gdalmetadata.find('<br>', providerpos + len(provstring))
#self.gdalprovider = gdalmetadata[int(providerpos +
# len(provstring)):int(brpos)]
#self.showInfo('GDAL provider: '+self.gdalprovider)
#drivername = self.gdalprovider.encode('ascii', 'ignore')
#theDriver = gdal.GetDriverByName(drivername)
#if theDriver is None:
# self.showInfo("Unable to get the raster driver")
#else:
#data theMetadata = theDriver.GetMetadata()
#self.showInfo("Driver metadata: "+str(theMetadata))
#if ((gdal.DCAP_CREATE in theMetadata) and
# theMetadata[gdal.DCAP_CREATE] == 'YES'):
# self.canCreate = True
#if (theMetadata.has_key(gdal.DCAP_CREATECOPY) and
#if ((gdal.DCAP_CREATECOPY in theMetadata) and
# theMetadata[gdal.DCAP_CREATECOPY] == 'YES'):
# self.canCreateCopy = True
#self.showInfo('raster provider type: ' +
# str(self.inputlayer.providerType()))
# Determine the file suffix
#self.gdalext = ""
#if gdal.DMD_EXTENSION in theMetadata:
# self.gdalext = "." + theMetadata[gdal.DMD_EXTENSION]
#else:
# self.showInfo("No extension available in GDAL metadata")
# by parsing the layer metadata looking for
# "Dataset Description"
#descstring = 'Dataset Description</p>\n<p>'
#descpos = gdalmetadata.find(descstring)
#ppos = gdalmetadata.find('</p>',descpos+len(descstring))
#filename = gdalmetadata[descpos+len(descstring):ppos]
#self.gdalext = splitext(filename)[1]
#self.showInfo('GDAL extension: '+self.gdalext)
# Determine the datatype
#datatypestring = 'Data Type</p>\n<p>'
#datatypepos = gdalmetadata.find(datatypestring)
#ppos = gdalmetadata.find('</p>',
# datatypepos + len(datatypestring))
#datatypedesc = gdalmetadata[datatypepos +
# len(datatypestring):ppos]
#shortdesc = datatypedesc.split()[0]
#self.showInfo('GDAL data type: GDT_'+shortdesc)
# Call the findGdalDatatype function
#self.findGdalDatatype(shortdesc)
# self.button_box.button(QDialogButtonBox.Ok).setEnabled(True)
self.button_box.button(QDialogButtonBox.Ok).setEnabled(True)
self.calcHistPushButton.setEnabled(True)
self.suggestlevelsPushButton.setEnabled(True)
def bandChanged(self):
band = self.bandComboBox.currentIndex() + 1
self.showInfo("Band changed: " + str(band))
statistics = self.inputrasterprovider.bandStatistics(band)
#self.showInfo("Band statistics: " + str(statistics.minimumValue) +
# " - " + str(statistics.maximumValue) +
# " - " + str(statistics.mean))
self.bandmin = statistics.minimumValue
self.bandmax = statistics.maximumValue
dt = self.inputrasterprovider.dataType(band)
# Integer data type
if (dt == Qgis.Byte or dt == Qgis.UInt16 or dt == Qgis.Int16
or dt == Qgis.UInt32 or dt == Qgis.Int32):
self.intband = True
self.minValueSpinBox.setDecimals(0)
self.maxValueSpinBox.setDecimals(0)
self.levelSpinBox.setDecimals(0)
self.bandMinLabel.setText(str(int(statistics.minimumValue)))
self.bandMaxLabel.setText(str(int(statistics.maximumValue)))
else:
self.intband = False
self.minValueSpinBox.setDecimals(5)
self.maxValueSpinBox.setDecimals(5)
self.levelSpinBox.setDecimals(5)
minlabtext = "{0:.5f}".format(statistics.minimumValue)
self.bandMinLabel.setText(minlabtext)
maxlabtext = "{0:.5f}".format(statistics.maximumValue)
self.bandMaxLabel.setText(maxlabtext)
#self.minValueSpinBox.setMinimum(statistics.minimumValue)
self.maxValueSpinBox.setMinimum(statistics.minimumValue)
#self.minValueSpinBox.setMaximum(statistics.maximumValue)
self.maxValueSpinBox.setMaximum(statistics.maximumValue)
#self.minValueSpinBox.setValue(statistics.minimumValue)
if not (statistics.statsGathered & statistics.Mean):
bandmean = (statistics.minimumValue + statistics.maximumValue) / 2
else:
#self.showInfo("statsgathered: " + str(statistics.statsGathered))
bandmean = statistics.mean
if self.intband:
self.minValueSpinBox.setValue(int(ceil(bandmean)))
else:
self.minValueSpinBox.setValue(bandmean)
self.maxValueSpinBox.setValue(statistics.maximumValue)
self.histMinValue.setText(str(statistics.minimumValue))
self.histMaxValue.setText(str(statistics.maximumValue))
self.levelSpinBox.setMinimum(statistics.minimumValue)
self.levelSpinBox.setMaximum(statistics.maximumValue)
self.histogramAvailable = False
#if self.inputrasterprovider.hasStatistics(band):
#if statistics.statsGathered:
#histogram = statistics.histogramVector
#self.showInfo("Histogram: " + str(histogram))
#range = min to max
#np.histogram(band, 50, range)
def minmaxvalueChanged(self):
#if self.minValueSpinBox is None:
# return
minvalue = self.minValueSpinBox.value()
#if minvalue is None:
# return
#if self.maxValueSpinBox is None:
# return
maxvalue = self.maxValueSpinBox.value()
#if maxvalue is None:
# return
if isnan(maxvalue) or isnan(minvalue):
return
self.showInfo("minvalue: " + str(minvalue) + " Maxvalue: " +
str(maxvalue))
#if self.intband:
# minvalue = int(minvalue)
# maxvalue = int(maxvalue)
if abs(maxvalue - minvalue) < 0.00001:
#if maxvalue == maxvalue:
self.calcHistPushButton.setEnabled(False)
else:
self.calcHistPushButton.setEnabled(True)
# Update the min and max value spinboxes
self.minValueSpinBox.setMaximum(maxvalue)
self.maxValueSpinBox.setMinimum(minvalue)
self.minValueSpinBox.setMinimum(self.bandmin)
def minmaxvalueEdFinished(self):
minvalue = self.minValueSpinBox.value()
maxvalue = self.maxValueSpinBox.value()
if self.intband:
minvalue = int(minvalue)
maxvalue = int(maxvalue)
self.showInfo("minvalue: " + str(minvalue) + " Maxvalue: " +
str(maxvalue))
# Update the spin box for adding levels
self.levelSpinBox.setMinimum(minvalue)
self.levelSpinBox.setMaximum(maxvalue)
if self.levelSpinBox.value() < minvalue:
self.levelSpinBox.setValue(minvalue)
if self.levelSpinBox.value() > maxvalue:
self.levelSpinBox.setValue(maxvalue)
# Update the min and max value spinboxes
self.minValueSpinBox.setMaximum(maxvalue)
self.maxValueSpinBox.setMinimum(minvalue)
# Adjust the levels:
i = 0
while self.levelsListView.model().item(i):
#for i in range(self.levelsListView.model().rowCount()):
#self.showInfo("Element: " +
# str(self.levelsListView.model().item(i).text()))
#continue
value = float(self.levelsListView.model().item(i).text())
if value < minvalue:
if i == 0:
self.levelsListView.model().item(i).setText(str(minvalue))
i = i + 1
else:
self.levelsListView.model().removeRow(i)
elif value > maxvalue:
if i == self.levelsListView.model().rowCount() - 1:
self.levelsListView.model().item(i).setText(str(maxvalue))
i = i + 1
else:
self.levelsListView.model().removeRow(i)
else:
i = i + 1
self.drawHistogram()
def calculateHistogram(self):
self.showInfo("Calculating histogram...")
if self.inputlayer is None:
return
self.showInfo("Calculating histogram...")
# Check if there is only one value
myrange = (self.minValueSpinBox.value(), self.maxValueSpinBox.value())
self.inputextent = self.inputlayer.extent()
self.inputrdp = self.inputlayer.dataProvider()
width = self.inputlayer.width()
height = self.inputlayer.height()
if width == 0 or height == 0:
self.showInfo("Image has zero width or height")
return
extwidth = self.inputextent.width()
extheight = self.inputextent.height()
# Read the raster block and get the maximum value
rasterblock = self.inputrdp.block(1, self.inputextent, width, height)
# Create a numpy array version of the image
imageMat = np.zeros((height, width), dtype=np.float16)
# This one takes a lot of time!
for row in range(height):
for column in range(width):
imageMat[row, column] = rasterblock.value(row, column)
self.showInfo("Image: " + str(height) + ", " + str(width) +
" - " + str(imageMat[row, column]))
self.histo = np.histogram(imageMat, self.histobins, myrange)
#relevantpixels = imageMat[np.where(imageMat >= bandval)]
minlevel = float(self.bandMinLabel.text())
relevantpixels = imageMat[np.where(imageMat >= minlevel)]
#self.showInfo("Histogram: " + str(self.histo))
nanpercentage = 100.0 - 100.0 * len(relevantpixels) / (width * height)
self.bandNANLabel.setText("{0:.1f}".format(nanpercentage))
#self.showInfo("Percentage NAN: " + str(100.0 - 100.0 *
# len(relevantpixels) / (width * height)))
#self.showInfo("First element: " + str(self.histo[0]))
#self.showInfo("First element, first: " + str(self.histo[0][0]))
#self.showInfo("First element, second: " + str(self.histo[0][1]))
self.histMinValue.setText(str(self.minValueSpinBox.value()))
self.histMaxValue.setText(str(self.maxValueSpinBox.value()))
if self.intband:
self.histMinValue.setText(str(int(self.minValueSpinBox.value())))
self.histMaxValue.setText(str(int(self.maxValueSpinBox.value())))
self.histogramAvailable = True
self.drawHistogram()
def drawHistogram(self):
#if self.inputlayer is None:
# return
self.showInfo("Drawing histogram...")
viewprect = QRectF(self.histoGraphicsView.viewport().rect())
self.histoGraphicsView.setSceneRect(viewprect)
self.setupScene.clear()
self.setupScene.update()
histbottom = self.histoGraphicsView.sceneRect().bottom()
histtop = self.histoGraphicsView.sceneRect().top()
left = self.histoGraphicsView.sceneRect().left() + self.histopadding
right = self.histoGraphicsView.sceneRect().right() - self.histopadding
histheight = histbottom - histtop
histwidth = right - left
step = 1.0 * histwidth / self.histobins
maxlength = histheight
padding = 1
ll = QPoint(self.histopadding - 1, histheight - padding)
start = QPointF(self.histoGraphicsView.mapToScene(ll))
# Check if there is only one value
#myrange = (self.minValueSpinBox.value(),self.maxValueSpinBox.value())
if self.histogramAvailable:
maxvalue = 0.0
for i in range(len(self.histo[0])):
if self.histo[0][i] > maxvalue:
maxvalue = self.histo[0][i]
if maxvalue == 0:
return
self.maxBinNumber.setText(str(maxvalue))
# Create the histogram:
#self.showInfo("maxvalue: " + str(maxvalue))
#self.showInfo("maxlength: " + str(maxlength))
#self.showInfo("step: " + str(step))
for i in range(self.histobins):
binnumber = self.histo[0][i]
if binnumber == 0:
continue
height = (1.0 * self.histo[0][i] / maxvalue *
(maxlength - padding))
rectangle = QGraphicsRectItem(start.x() + step * i, start.y(),
step, -height)
rectangle.setPen(QPen(QColor(102, 102, 102)))
rectangle.setBrush(QBrush(QColor(240, 240, 240)))
self.setupScene.addItem(rectangle)
#self.showInfo(str(i) + ": " + str(height))
#if self.levelsListView.model().rowCount() > 0:
# Add lines for the levels
minvalue = float(self.histMinValue.text())
maxvalue = float(self.histMaxValue.text())
datarange = maxvalue - minvalue
if datarange == 0:
return
i = 0
while self.levelsListView.model().item(i):
#self.showInfo("Element: " +
# str(self.levelsListView.model().item(i).text()))
#continue
value = float(self.levelsListView.model().item(i).text())
xvalue = start.x() + histwidth * (value - minvalue) / datarange
line = QGraphicsLineItem(xvalue, 0, xvalue, histheight)
if i == 0 or i == (self.levelsListView.model().rowCount() - 1):
line.setPen(QPen(QColor(204, 0, 0)))
else:
line.setPen(QPen(QColor(0, 204, 0)))
self.setupScene.addItem(line)
i = i + 1
def suggestLevels(self):
self.listModel.clear()
self.showInfo("Suggesting levels")
levels = self.levelsSpinBox.value()
startvalue = self.minValueSpinBox.value()
endvalue = self.maxValueSpinBox.value()
increment = (endvalue - startvalue) / levels
for i in range(levels + 1):
value = startvalue + increment * i
if self.intband:
value = int(value)
item = QStandardItem(str(value))
self.listModel.appendRow(item)
self.drawHistogram()
def addLevel(self):
newvalue = self.levelSpinBox.value()
if self.intband:
newvalue = int(newvalue)
for i in range(self.listModel.rowCount()):
# Check if the value is already in the list
if self.listModel.item(i).text() == str(newvalue):
return
else:
# Maintain a sorted list of distances
if (float(self.listModel.item(i).text()) > float(
str(newvalue))):
item = QStandardItem(str(newvalue))
self.listModel.insertRow(i, item)
self.drawHistogram()
return
item = QStandardItem(str(newvalue))
self.listModel.appendRow(item)
#if self.histogramAvailable:
# addLevelsToHistogram()
self.drawHistogram()
def removeLevel(self):
self.levelsListView.setUpdatesEnabled(False)
indexes = self.levelsListView.selectedIndexes()
indexes.sort()
for i in range(len(indexes) - 1, -1, -1):
self.listModel.removeRow(indexes[i].row())
self.levelsListView.setUpdatesEnabled(True)
#if self.histogramAvailable:
# removeLevelFromHistogram()
self.drawHistogram()
def layerlistchanged(self):
self.layerlistchanging = True
self.showInfo("Layer list changed")
# Repopulate the input layer combo box
# Save the currently selected input layer
inputlayerid = self.inputlayerid
self.inputRaster.clear()
for alayer in self.iface.legendInterface().layers():
if alayer.type() == QgsMapLayer.RasterLayer:
gdalmetadata = alayer.metadata()
# Skip WMS layers
WMSstring = 'Web Map Service'
wmspos = gdalmetadata.find(WMSstring)
if wmspos != -1:
continue
self.inputRaster.addItem(alayer.name(), alayer.id())
# Set the previous selection
for i in range(self.inputRaster.count()):
if self.inputRaster.itemData(i) == inputlayerid:
self.inputRaster.setCurrentIndex(i)
self.layerlistchanging = False
#self.updateui()
def updateui(self):
"""Do the necessary updates after a layer selection has
been changed."""
#if self.layerlistchanged:
# return
#self.outputRaster.setText(self.inputRaster.currentText() +
# '_' + 'thinned')
layerindex = self.inputRaster.currentIndex()
layerId = self.inputRaster.itemData(layerindex)
#inputlayer = QgsMapLayerRegistry.instance().mapLayer(layerId)
inputlayer = QgsProject.instance().mapLayer(layerId)
if inputlayer is not None:
pass
else:
pass
def findGdalDatatype(self, shortdesc):
gdaldatatype = None
# // Unknown or unspecified type
# GDT_Unknown = GDALDataType(C.GDT_Unknown)
if shortdesc == 'Unknown':
gdaldatatype = gdal.GDT_Unknown
# // Eight bit unsigned integer
# GDT_Byte = GDALDataType(C.GDT_Byte)
elif shortdesc == 'Byte':
gdaldatatype = gdal.GDT_Byte
# // Sixteen bit unsigned integer
# GDT_UInt16 = GDALDataType(C.GDT_UInt16)
elif shortdesc == 'UInt16':
gdaldatatype = gdal.GDT_UInt16
# // Sixteen bit signed integer
# GDT_Int16 = GDALDataType(C.GDT_Int16)
elif shortdesc == 'Int16':
gdaldatatype = gdal.GDT_Int16
# // Thirty two bit unsigned integer
# GDT_UInt32 = GDALDataType(C.GDT_UInt32)
elif shortdesc == 'UInt32':
gdaldatatype = gdal.GDT_UInt32
# // Thirty two bit signed integer
# GDT_Int32 = GDALDataType(C.GDT_Int32)
elif shortdesc == 'Int32':
gdaldatatype = gdal.GDT_Int32
# // Thirty two bit floating point
# GDT_Float32 = GDALDataType(C.GDT_Float32)
elif shortdesc == 'Float32':
gdaldatatype = gdal.GDT_Float32
# // Sixty four bit floating point
# GDT_Float64 = GDALDataType(C.GDT_Float64)
elif shortdesc == 'Float64':
gdaldatatype = gdal.GDT_Float64
# // Complex Int16
# GDT_CInt16 = GDALDataType(C.GDT_CInt16)
elif shortdesc == 'CInt16':
gdaldatatype = gdal.CInt16
# // Complex Int32
# GDT_CInt32 = GDALDataType(C.GDT_CInt32)
elif shortdesc == 'CInt32':
gdaldatatype = gdal.CInt32
# // Complex Float32
# GDT_CFloat32 = GDALDataType(C.GDT_CFloat32)
elif shortdesc == 'CFloat32':
gdaldatatype = gdal.CFloat32
# // Complex Float64
# GDT_CFloat64 = GDALDataType(C.GDT_CFloat64)
elif shortdesc == 'CFloat64':
gdaldatatype = gdal.CFloat64
# // maximum type # + 1
# GDT_TypeCount = GDALDataType(C.GDT_TypeCount)
elif shortdesc == 'TypeCount':
gdaldatatype = gdal.TypeCount
self.gdaldatatype = gdaldatatype
def killWorker(self):
"""Kill the worker thread."""
if self.worker is not None:
QgsMessageLog.logMessage(self.tr('Killing worker'),
self.THINGREYSCALE, Qgis.Info)
self.worker.kill()
def showError(self, text):
"""Show an error."""
self.iface.messageBar().pushMessage(self.tr('Error'),
text,
level=QgsMessageBar.CRITICAL,
duration=3)
QgsMessageLog.logMessage('Error: ' + text, self.THINGREYSCALE,
QgsMessageLog.CRITICAL)
def showWarning(self, text):
"""Show a warning."""
self.iface.messageBar().pushMessage(self.tr('Warning'),
text,
level=QgsMessageBar.WARNING,
duration=2)
QgsMessageLog.logMessage('Warning: ' + text, self.THINGREYSCALE,
QgsMessageLog.WARNING)
def showInfo(self, text):
"""Show info."""
self.iface.messageBar().pushMessage(self.tr('Info'),
text,
level=Qgis.Info,
duration=2)
QgsMessageLog.logMessage('Info: ' + text, self.THINGREYSCALE,
Qgis.Info)
# def help(self):
# #QDesktopServices.openUrl(QUrl.fromLocalFile(self.plugin_dir +
# "/help/build/html/index.html"))
# QDesktopServices.openUrl(QUrl.fromLocalFile(self.plugin_dir +
# "/help/index.html"))
# #showPluginHelp()
def tr(self, message):
"""Get the translation for a string using Qt translation API.
:param message: String for translation.
:type message: str, QString
:returns: Translated version of message.
:rtype: QString
"""
return QCoreApplication.translate('ThinGreyScaleDialog', message)
def browse(self):
settings = QSettings()
key = '/UI/lastShapefileDir'
outDir = settings.value(key)
home = outDir
#outDir = expanduser("~")
#filter = (self.DEFAULTPROVIDER + " (*" +
# self.DEFAULTEXTENSION + ");;All files (*)")
filter = (self.DEFAULTPROVIDER + " (*" + self.DEFAULTEXTENSION +
self.EXTRAEXTENSION + ")")
#if (self.gdalprovider != self.DEFAULTPROVIDER and
# (self.canCreateCopy or
# self.canCreate)):
# filter = (self.gdalprovider + " (*" + self.gdalext +
# ");;" + filter)
outFilePath = QFileDialog.getSaveFileName(
self, 'Specify file name for skeleton', outDir, filter)
outFilePath = unicode(outFilePath)
if outFilePath:
root, ext = splitext(outFilePath)
if ext.lower() != '.tif' and ext.lower() != '.tiff':
outFilePath = '%s.tif' % outFilePath
outDir = dirname(outFilePath)
settings.setValue(key, outDir)
# (self.canCreateCopy or self.canCreate):
# fileName = splitext(str(fileName))[0]+self.gdalext
self.outputRaster.setText(outFilePath)
# Overriding
def resizeEvent(self, event):
#self.showInfo("resizeEvent")
self.calculateHistogram()
def help(self):
#QDesktopServices.openUrl(QUrl.fromLocalFile(
# self.plugin_dir + "/help/html/index.html"))
showPluginHelp(None, "help/html/index")
# Implement the accept method to avoid exiting the dialog when
# starting the work
def accept(self):
"""Accept override."""
pass
# Implement the reject method to have the possibility to avoid
# exiting the dialog when cancelling
def reject(self):
"""Reject override."""
# exit the dialog
QDialog.reject(self)
class SchematisationDownload(uicls, basecls):
"""Dialog for schematisation download."""
TABLE_LIMIT = 10
def __init__(self, plugin_dock, parent=None):
super().__init__(parent)
self.setupUi(self)
self.plugin_dock = plugin_dock
self.working_dir = self.plugin_dock.plugin_settings.working_dir
self.communication = self.plugin_dock.communication
self.threedi_api = self.plugin_dock.threedi_api
self.schematisations = None
self.revisions = None
self.local_schematisations = list_local_schematisations(self.working_dir)
self.downloaded_local_schematisation = None
self.tv_schematisations_model = QStandardItemModel()
self.schematisations_tv.setModel(self.tv_schematisations_model)
self.tv_revisions_model = QStandardItemModel()
self.revisions_tv.setModel(self.tv_revisions_model)
self.pb_schematisations_prev_page.clicked.connect(self.move_schematisations_backward)
self.pb_schematisations_next_page.clicked.connect(self.move_schematisations_forward)
self.schematisations_page_sbox.valueChanged.connect(self.fetch_schematisations)
self.pb_revisions_prev_page.clicked.connect(self.move_revisions_backward)
self.pb_revisions_next_page.clicked.connect(self.move_revisions_forward)
self.revisions_page_sbox.valueChanged.connect(self.fetch_revisions)
self.pb_revisions_fetch.clicked.connect(self.fetch_revisions)
self.pb_download.clicked.connect(self.download_schematisation_revision)
self.pb_cancel.clicked.connect(self.cancel_download_schematisation_revision)
self.schematisations_search_le.returnPressed.connect(self.search_schematisations)
self.schematisations_tv.selectionModel().selectionChanged.connect(self.toggle_fetch_revisions)
self.revisions_tv.selectionModel().selectionChanged.connect(self.toggle_download_schematisation_revision)
self.fetch_schematisations()
def toggle_fetch_revisions(self):
"""Toggle fetch revisions button if any schematisation is selected."""
selection_model = self.schematisations_tv.selectionModel()
if selection_model.hasSelection():
self.pb_revisions_fetch.setEnabled(True)
else:
self.pb_revisions_fetch.setDisabled(True)
self.tv_revisions_model.clear()
self.revisions_page_sbox.setMaximum(1)
self.revisions_page_sbox.setSuffix(" / 1")
self.toggle_download_schematisation_revision()
def toggle_download_schematisation_revision(self):
"""Toggle download button if any schematisation revision is selected."""
selection_model = self.revisions_tv.selectionModel()
if selection_model.hasSelection():
self.pb_download.setEnabled(True)
else:
self.pb_download.setDisabled(True)
def move_schematisations_backward(self):
"""Moving to the previous schematisations results page."""
self.schematisations_page_sbox.setValue(self.schematisations_page_sbox.value() - 1)
def move_schematisations_forward(self):
"""Moving to the next schematisations results page."""
self.schematisations_page_sbox.setValue(self.schematisations_page_sbox.value() + 1)
def search_schematisations(self):
"""Method used for searching schematisations with text typed withing search bar."""
self.schematisations_page_sbox.valueChanged.disconnect(self.fetch_schematisations)
self.schematisations_page_sbox.setValue(1)
self.schematisations_page_sbox.valueChanged.connect(self.fetch_schematisations)
self.fetch_schematisations()
def move_revisions_backward(self):
"""Moving to the previous revisions results page."""
self.revisions_page_sbox.setValue(self.revisions_page_sbox.value() - 1)
def move_revisions_forward(self):
"""Moving to the next revisions results page."""
self.revisions_page_sbox.setValue(self.revisions_page_sbox.value() + 1)
def fetch_schematisations(self):
"""Fetching schematisation list."""
try:
tc = ThreediCalls(self.threedi_api)
offset = (self.schematisations_page_sbox.value() - 1) * self.TABLE_LIMIT
text = self.schematisations_search_le.text()
schematisations, schematisations_count = tc.fetch_schematisations_with_count(
limit=self.TABLE_LIMIT, offset=offset, name_contains=text
)
pages_nr = ceil(schematisations_count / self.TABLE_LIMIT) or 1
self.schematisations_page_sbox.setMaximum(pages_nr)
self.schematisations_page_sbox.setSuffix(f" / {pages_nr}")
self.tv_schematisations_model.clear()
header = ["Schematisation name", "Slug", "Owner", "Created by"]
self.tv_schematisations_model.setHorizontalHeaderLabels(header)
for schematisation in schematisations:
name_item = QStandardItem(schematisation.name)
name_item.setData(schematisation, role=Qt.UserRole)
slug_item = QStandardItem(schematisation.slug)
organisation = self.plugin_dock.organisations[schematisation.owner]
owner_item = QStandardItem(organisation.name)
created_by_item = QStandardItem(schematisation.created_by)
self.tv_schematisations_model.appendRow([name_item, slug_item, owner_item, created_by_item])
for i in range(len(header)):
self.schematisations_tv.resizeColumnToContents(i)
self.schematisations = schematisations
except ApiException as e:
self.close()
error_msg = extract_error_message(e)
self.communication.show_error(error_msg)
except Exception as e:
self.close()
error_msg = f"Error: {e}"
self.communication.show_error(error_msg)
def fetch_revisions(self):
"""Fetching schematisation revisions list."""
try:
tc = ThreediCalls(self.threedi_api)
offset = (self.revisions_page_sbox.value() - 1) * self.TABLE_LIMIT
selected_schematisation = self.get_selected_schematisation()
schematisation_pk = selected_schematisation.id
revisions, revisions_count = tc.fetch_schematisation_revisions_with_count(
schematisation_pk, limit=self.TABLE_LIMIT, offset=offset
)
pages_nr = ceil(revisions_count / self.TABLE_LIMIT) or 1
self.revisions_page_sbox.setMaximum(pages_nr)
self.revisions_page_sbox.setSuffix(f" / {pages_nr}")
self.tv_revisions_model.clear()
header = ["Revision number", "Commit message", "Committed by", "Commit date"]
self.tv_revisions_model.setHorizontalHeaderLabels(header)
for revision in revisions:
number_item = QStandardItem(str(revision.number))
number_item.setData(revision, role=Qt.UserRole)
commit_message_item = QStandardItem(revision.commit_message or "")
commit_user_item = QStandardItem(revision.commit_user or "")
commit_date = revision.commit_date.strftime("%d-%m-%Y") if revision.commit_date else ""
commit_date_item = QStandardItem(commit_date)
self.tv_revisions_model.appendRow(
[number_item, commit_message_item, commit_user_item, commit_date_item]
)
for i in range(len(header)):
self.revisions_tv.resizeColumnToContents(i)
self.revisions = revisions
except ApiException as e:
error_msg = extract_error_message(e)
self.communication.show_error(error_msg)
except Exception as e:
error_msg = f"Error: {e}"
self.communication.show_error(error_msg)
def get_selected_schematisation(self):
"""Get currently selected schematisation."""
index = self.schematisations_tv.currentIndex()
if index.isValid():
current_row = index.row()
name_item = self.tv_schematisations_model.item(current_row, 0)
selected_schematisation = name_item.data(Qt.UserRole)
else:
selected_schematisation = None
return selected_schematisation
def get_selected_revision(self):
"""Get currently selected revision."""
index = self.revisions_tv.currentIndex()
if index.isValid():
current_row = index.row()
name_item = self.tv_revisions_model.item(current_row, 0)
selected_revision = name_item.data(Qt.UserRole)
else:
selected_revision = None
return selected_revision
def download_schematisation_revision(self):
"""Downloading selected schematisation revision."""
selected_schematisation = self.get_selected_schematisation()
selected_revision = self.get_selected_revision()
self.download_required_files(selected_schematisation, selected_revision)
if self.downloaded_local_schematisation:
self.close()
def download_required_files(self, schematisation, revision):
"""Download required schematisation revision files."""
try:
latest_online_revision = max([rev.number for rev in self.revisions])
schematisation_pk = schematisation.id
schematisation_name = schematisation.name
revision_pk = revision.id
revision_number = revision.number
revision_sqlite = revision.sqlite
is_latest_revision = revision_number == latest_online_revision
try:
local_schematisation = self.local_schematisations[schematisation_pk]
local_schematisation_present = True
except KeyError:
local_schematisation = LocalSchematisation(
self.working_dir, schematisation_pk, schematisation_name, create=True
)
self.local_schematisations[schematisation_pk] = local_schematisation
local_schematisation_present = False
def decision_tree():
title = "Pick action"
question = f"Replace local WIP or store as a revision {revision_number}?"
picked_action_name = self.communication.custom_ask(self, title, question, "Replace", "Store")
if picked_action_name == "Replace":
# Replace
local_schematisation.set_wip_revision(revision_number)
schema_db_dir = local_schematisation.wip_revision.schematisation_dir
else:
# Store as a separate revision
if revision_number in local_schematisation.revisions:
question = f"Replace local revision {revision_number} or Cancel?"
picked_action_name = self.communication.custom_ask(self, title, question, "Replace", "Cancel")
if picked_action_name == "Replace":
local_revision = local_schematisation.add_revision(revision_number)
schema_db_dir = local_revision.schematisation_dir
else:
schema_db_dir = None
else:
local_revision = local_schematisation.add_revision(revision_number)
schema_db_dir = local_revision.schematisation_dir
return schema_db_dir
if local_schematisation_present:
if is_latest_revision:
if local_schematisation.wip_revision is None:
# WIP not exist
local_schematisation.set_wip_revision(revision_number)
schematisation_db_dir = local_schematisation.wip_revision.schematisation_dir
else:
# WIP exist
schematisation_db_dir = decision_tree()
else:
schematisation_db_dir = decision_tree()
else:
local_schematisation.set_wip_revision(revision_number)
schematisation_db_dir = local_schematisation.wip_revision.schematisation_dir
if not schematisation_db_dir:
return
tc = ThreediCalls(self.threedi_api)
sqlite_download = tc.download_schematisation_revision_sqlite(schematisation_pk, revision_pk)
rasters_downloads = []
for raster_file in revision.rasters or []:
raster_download = tc.download_schematisation_revision_raster(
raster_file.id, schematisation_pk, revision_pk
)
rasters_downloads.append((raster_file.name, raster_download))
if revision_pk in local_schematisation.revisions:
local_schematisation.add_revision(revision_pk)
zip_filepath = os.path.join(schematisation_db_dir, revision_sqlite.file.filename)
self.pbar_download.setMaximum(len(rasters_downloads) + 1)
current_progress = 0
self.pbar_download.setValue(current_progress)
get_download_file(sqlite_download, zip_filepath)
content_list = unzip_archive(zip_filepath)
os.remove(zip_filepath)
sqlite_file = content_list[0]
current_progress += 1
self.pbar_download.setValue(current_progress)
for raster_filename, raster_download in rasters_downloads:
raster_filepath = os.path.join(schematisation_db_dir, "rasters", raster_filename)
get_download_file(raster_download, raster_filepath)
current_progress += 1
self.pbar_download.setValue(current_progress)
local_schematisation.wip_revision.sqlite_filename = sqlite_file
self.downloaded_local_schematisation = local_schematisation
sleep(1)
msg = f"Schematisation '{schematisation_name} (revision {revision_number})' downloaded!"
self.communication.bar_info(msg, log_text_color=QColor(Qt.darkGreen))
except ApiException as e:
error_msg = extract_error_message(e)
self.communication.show_error(error_msg)
except Exception as e:
error_msg = f"Error: {e}"
self.communication.show_error(error_msg)
def cancel_download_schematisation_revision(self):
"""Cancel schematisation revision download."""
self.close()
class QRAVEMetaWidget(QDockWidget, Ui_QRAVEMetaWidgetBase):
def __init__(self, parent=None):
"""Constructor."""
super(QRAVEMetaWidget, self).__init__(parent)
self.setupUi(self)
self.treeView.setContextMenuPolicy(Qt.CustomContextMenu)
self.treeView.customContextMenuRequested.connect(self.open_menu)
self.treeView.doubleClicked.connect(self.default_tree_action)
self.settings = Settings()
self.model = QStandardItemModel()
self.treeView.setModel(self.model)
self.meta = None
self.menu = QMenu()
# Initialize our classes
self.hide()
@pyqtSlot(str, str, dict, bool)
def load(self, label: str, meta_type: str, meta: dict, show: bool = False):
# re-initialize our model
self.model.clear()
self.meta = meta
root_item = self.model.invisibleRootItem()
self.model.setColumnCount(2)
self.model.setHorizontalHeaderLabels(['Meta Name', 'Meta Value'])
if meta_type == MetaType.PROJECT:
self.treeView.setHeaderHidden(False)
self.setWindowTitle('Project MetaData: {}'.format(label))
self.treeView.setEnabled(True)
if meta is not None and len(meta.keys()) > 0:
if 'project' in meta and len(meta['project'].keys()) > 0:
proj_meta = QStandardItem('Project Meta')
proj_meta_font = proj_meta.font()
proj_meta_font.setBold(True)
proj_meta.setFont(proj_meta_font)
for k, v in meta['project'].items():
proj_meta.appendRow(
[QStandardItem(k),
QStandardItem(v)])
root_item.appendRow(proj_meta)
if 'warehouse' in meta and len(meta['warehouse'].keys()) > 0:
wh_meta = QStandardItem('Warehouse Meta')
wh_meta_font = proj_meta.font()
wh_meta_font.setBold(True)
wh_meta.setFont(wh_meta_font)
for k, v in meta['warehouse'].items():
wh_meta.appendRow([QStandardItem(k), QStandardItem(v)])
root_item.appendRow(wh_meta)
elif meta_type == MetaType.FOLDER:
self.setWindowTitle('Folder: {}'.format(label))
self.treeView.setHeaderHidden(True)
self.treeView.setEnabled(False)
self.model.setColumnCount(1)
self.model.setHorizontalHeaderLabels(['Meta Name'])
no_item = QStandardItem('Folders have no MetaData')
no_item.setTextAlignment(Qt.AlignCenter)
no_f = no_item.font()
no_f.setItalic(True)
no_item.setFont(no_f)
root_item.appendRow(no_item)
elif meta_type == MetaType.LAYER:
self.setWindowTitle('Layer MetaData: {}'.format(label))
self.treeView.setEnabled(True)
self.treeView.setHeaderHidden(False)
if meta is not None and len(meta.keys()) > 0:
for k, v in meta.items():
root_item.appendRow([QStandardItem(k), QStandardItem(v)])
else:
self.treeView.setHeaderHidden(True)
self.treeView.setEnabled(False)
self.model.setColumnCount(1)
self.model.setHorizontalHeaderLabels(['Meta Name'])
no_item = QStandardItem('This layer has no MetaData')
no_item.setTextAlignment(Qt.AlignCenter)
no_f = no_item.font()
no_f.setItalic(True)
no_item.setFont(no_f)
root_item.appendRow(no_item)
elif meta_type == MetaType.NONE:
self.treeView.setHeaderHidden(True)
self.treeView.setEnabled(False)
self.model.setColumnCount(1)
self.setWindowTitle('Riverscapes MetaData: {}'.format(label))
no_item = QStandardItem('This item cannot have metadata')
no_item.setTextAlignment(Qt.AlignCenter)
no_f = no_item.font()
no_f.setItalic(True)
no_item.setFont(no_f)
root_item.appendRow(no_item)
return
# self.tree.header().setDefaultSectionSize(180)
# self._populateTree(self.tree, )
# Finally expand all levels
self.treeView.expandAll()
if show is True:
self.show()
def closeEvent(self, event):
self.hide()
def default_tree_action(self, index):
item = self.model.itemFromIndex(index)
data = item.data(Qt.UserRole)
def open_menu(self, position):
indexes = self.treeView.selectedIndexes()
if len(indexes) < 1 or self.meta is None or len(self.meta.keys()) == 0:
return
# No multiselect so there is only ever one item
item_name = self.model.itemFromIndex(indexes[0])
item_val = self.model.itemFromIndex(
indexes[1]) if len(indexes) > 0 else None
self.menu.clear()
if item_val is not None:
row_text = {item_name.text(): item_val.text()}
self.menu.addAction('Copy Name to Clipboard',
lambda: self.copy(item_name.text()))
self.menu.addAction('Copy Value to Clipboard',
lambda: self.copy(item_val.text()))
self.menu.addAction(
'Copy Row to Clipboard (json)', lambda: self.copy(
json.dumps(row_text, indent=4, sort_keys=True)))
self.menu.addAction(
'Copy All to Clipboard (json)',
lambda: self.copy(json.dumps(self.meta, indent=4, sort_keys=True)))
self.menu.exec_(self.treeView.viewport().mapToGlobal(position))
def copy(self, data: str):
cb = QGuiApplication.clipboard()
cb.clear(mode=cb.Clipboard)
cb.setText(data, mode=cb.Clipboard)
class ResourceSharingDialog(QDialog, FORM_CLASS):
TAB_ALL = 0
TAB_INSTALLED = 1
TAB_SETTINGS = 2
def __init__(self, parent=None, iface=None):
"""Constructor.
:param parent: Optional widget to use as parent
:type parent: QWidget
:param iface: An instance of QGisInterface
:type iface: QGisInterface
"""
super(ResourceSharingDialog, self).__init__(parent)
self.setupUi(self)
self.iface = iface
# Reconfigure UI
self.setModal(True)
self.button_edit.setEnabled(False)
self.button_delete.setEnabled(False)
self.button_install.setEnabled(False)
self.button_open.setEnabled(False)
self.button_uninstall.setEnabled(False)
# Set QListWidgetItem
# All
icon_all = QIcon()
icon_all.addFile(
resources_path('img', 'plugin.svg'),
QSize(),
QIcon.Normal,
QIcon.Off)
item_all = QListWidgetItem()
item_all.setIcon(icon_all)
item_all.setText(self.tr('All'))
# Installed
icon_installed = QIcon()
icon_installed.addFile(
resources_path('img', 'plugin-installed.svg'),
QSize(),
QIcon.Normal,
QIcon.Off)
item_installed = QListWidgetItem()
item_installed.setIcon(icon_installed)
item_installed.setText(self.tr('Installed'))
item_all.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
# Settings
icon_settings = QIcon()
icon_settings.addFile(
resources_path('img', 'settings.svg'),
QSize(),
QIcon.Normal,
QIcon.Off)
item_settings = QListWidgetItem()
item_settings.setIcon(icon_settings)
item_settings.setText(self.tr('Settings'))
item_all.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
# Add the list widget item to the widget
self.menu_list_widget.addItem(item_all)
self.menu_list_widget.addItem(item_installed)
self.menu_list_widget.addItem(item_settings)
# Init the message bar
self.message_bar = QgsMessageBar(self)
self.message_bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.vlayoutRightColumn.insertWidget(0, self.message_bar)
# Progress dialog for any long running process
self.progress_dialog = None
# Init repository manager
self.repository_manager = RepositoryManager()
self.collection_manager = CollectionManager()
# Collections list view
self.collections_model = QStandardItemModel(0, 1)
self.collections_model.sort(0, Qt.AscendingOrder)
self.collection_proxy = CustomSortFilterProxyModel(self)
self.collection_proxy.setSourceModel(self.collections_model)
self.list_view_collections.setModel(self.collection_proxy)
# Active selected collection
self._selected_collection_id = None
# Slots
self.button_add.clicked.connect(self.add_repository)
self.button_edit.clicked.connect(self.edit_repository)
self.button_delete.clicked.connect(self.delete_repository)
self.button_reload.clicked.connect(self.reload_repositories)
self.menu_list_widget.currentRowChanged.connect(self.set_current_tab)
self.list_view_collections.selectionModel().currentChanged.connect(
self.on_list_view_collections_clicked)
self.line_edit_filter.textChanged.connect(self.filter_collections)
self.button_install.clicked.connect(self.install_collection)
self.button_open.clicked.connect(self.open_collection)
self.button_uninstall.clicked.connect(self.uninstall_collection)
self.button_box.button(QDialogButtonBox.Help).clicked.connect(
self.open_help)
# Populate repositories widget and collections list view
self.populate_repositories_widget()
self.reload_collections_model()
def set_current_tab(self, index):
"""Set stacked widget based on active tab.
:param index: The index of the active list widget item.
:type index: int
"""
# Clear message bar first
self.message_bar.clearWidgets()
if index == (self.menu_list_widget.count() - 1):
# Switch to settings tab
self.stacked_menu_widget.setCurrentIndex(1)
else:
# Switch to plugins tab
if index == 1:
# Installed
self.collection_proxy.accepted_status = \
COLLECTION_INSTALLED_STATUS
# Set the web view
title = self.tr('Installed Collections')
description = self.tr(
'On the left you see the list of all collections '
'installed on your QGIS')
else:
# All
self.collection_proxy.accepted_status = COLLECTION_ALL_STATUS
# Set the web view
title = self.tr('All Collections')
description = self.tr(
'On the left you see the list of all collections '
'available from the repositories registered in the '
'settings.')
context = {
'resources_path': resources_path(),
'title': title,
'description': description
}
self.web_view_details.setHtml(
render_template('tab_description.html', context))
self.stacked_menu_widget.setCurrentIndex(0)
def add_repository(self):
"""Open add repository dialog."""
dlg = ManageRepositoryDialog(self)
if not dlg.exec_():
return
for repo in self.repository_manager.directories.values():
if dlg.line_edit_url.text().strip() == repo['url']:
self.message_bar.pushMessage(
self.tr(
'Unable to add another repository with the same URL!'),
Qgis.Critical, 5)
return
repo_name = dlg.line_edit_name.text()
repo_url = dlg.line_edit_url.text().strip()
repo_auth_cfg = dlg.line_edit_auth_id.text().strip()
if repo_name in self.repository_manager.directories:
repo_name += '(2)'
# Show progress dialog
self.show_progress_dialog("Fetching repository's metadata")
# Add repository
try:
status, description = self.repository_manager.add_directory(
repo_name, repo_url, repo_auth_cfg)
if status:
self.message_bar.pushMessage(
self.tr(
'Repository is successfully added'),
Qgis.Success, 5)
else:
self.message_bar.pushMessage(
self.tr(
'Unable to add repository: %s') % description,
Qgis.Critical, 5)
except Exception as e:
self.message_bar.pushMessage(
self.tr('%s') % e,
Qgis.Critical, 5)
finally:
self.progress_dialog.hide()
# Reload data and widget
self.reload_data_and_widget()
# Deactivate edit and delete button
self.button_edit.setEnabled(False)
self.button_delete.setEnabled(False)
def edit_repository(self):
"""Open edit repository dialog."""
selected_item = self.tree_repositories.currentItem()
if selected_item:
repo_name = selected_item.text(0)
if not repo_name:
return
# Check if it's the approved online dir repository
settings = QSettings()
settings.beginGroup(repo_settings_group())
if settings.value(repo_name + '/url') in \
self.repository_manager._online_directories.values():
self.message_bar.pushMessage(
self.tr(
'You can not edit the official repositories!'),
Qgis.Warning, 5)
return
dlg = ManageRepositoryDialog(self)
dlg.line_edit_name.setText(repo_name)
dlg.line_edit_url.setText(
self.repository_manager.directories[repo_name]['url'])
dlg.line_edit_auth_id.setText(
self.repository_manager.directories[repo_name]['auth_cfg'])
if not dlg.exec_():
return
# Check if the changed URL is already there in the repo
new_url = dlg.line_edit_url.text().strip()
old_url = self.repository_manager.directories[repo_name]['url']
for repo in self.repository_manager.directories.values():
if new_url == repo['url'] and (old_url != new_url):
self.message_bar.pushMessage(
self.tr('Unable to add another repository with the same '
'URL!'),
Qgis.Critical, 5)
return
new_name = dlg.line_edit_name.text()
if (new_name in self.repository_manager.directories) and (
new_name != repo_name):
new_name += '(2)'
new_auth_cfg = dlg.line_edit_auth_id.text()
# Show progress dialog
self.show_progress_dialog("Fetching repository's metadata")
# Edit repository
try:
status, description = self.repository_manager.edit_directory(
repo_name,
new_name,
old_url,
new_url,
new_auth_cfg
)
if status:
self.message_bar.pushMessage(
self.tr('Repository is successfully updated'),
Qgis.Success, 5)
else:
self.message_bar.pushMessage(
self.tr('Unable to add repository: %s') % description,
Qgis.Critical, 5)
except Exception as e:
self.message_bar.pushMessage(
self.tr('%s') % e, Qgis.Critical, 5)
finally:
self.progress_dialog.hide()
# Reload data and widget
self.reload_data_and_widget()
# Deactivate edit and delete button
self.button_edit.setEnabled(False)
self.button_delete.setEnabled(False)
def delete_repository(self):
"""Delete a repository in the tree widget."""
selected_item = self.tree_repositories.currentItem()
if selected_item:
repo_name = selected_item.text(0)
if not repo_name:
return
# Check if it's the approved online dir repository
repo_url = self.repository_manager.directories[repo_name]['url']
if repo_url in self.repository_manager._online_directories.values():
self.message_bar.pushMessage(
self.tr(
'You can not remove the official repositories!'),
Qgis.Warning, 5)
return
warning = self.tr('Are you sure you want to remove the following '
'repository?') + '\n' + repo_name
if QMessageBox.warning(
self,
self.tr('QGIS Resource Sharing'),
warning,
QMessageBox.Yes,
QMessageBox.No) == QMessageBox.No:
return
# Remove repository
installed_collections = \
self.collection_manager.get_installed_collections(repo_url)
if installed_collections:
message = ('You have some installed collections from this '
'repository. Please uninstall them first!')
self.message_bar.pushMessage(message, Qgis.Warning, 5)
else:
self.repository_manager.remove_directory(repo_name)
# Reload data and widget
self.reload_data_and_widget()
# Deactivate edit and delete button
self.button_edit.setEnabled(False)
self.button_delete.setEnabled(False)
def reload_repositories(self):
"""Slot for when user clicks reload repositories button."""
# Show progress dialog
self.show_progress_dialog('Reloading all repositories')
for repo_name in self.repository_manager.directories:
directory = self.repository_manager.directories[repo_name]
url = directory['url']
auth_cfg = directory['auth_cfg']
try:
status, description = self.repository_manager.reload_directory(
repo_name, url, auth_cfg)
if status:
self.message_bar.pushMessage(
self.tr(
'Repository %s is successfully reloaded') %
repo_name, Qgis.Info, 5)
else:
self.message_bar.pushMessage(
self.tr(
'Unable to reload %s: %s') % (
repo_name, description),
Qgis.Critical, 5)
except Exception as e:
self.message_bar.pushMessage(
self.tr('%s') % e,
Qgis.Critical, 5)
self.progress_dialog.hide()
# Reload data and widget
self.reload_data_and_widget()
def install_collection(self):
"""Slot for when user clicks download button."""
self.show_progress_dialog('Starting installation process...')
self.progress_dialog.canceled.connect(self.install_canceled)
self.installer_thread = QThread()
self.installer_worker = CollectionInstaller(
self.collection_manager, self._selected_collection_id)
self.installer_worker.moveToThread(self.installer_thread)
self.installer_worker.finished.connect(self.install_finished)
self.installer_worker.aborted.connect(self.install_aborted)
self.installer_worker.progress.connect(self.install_progress)
self.installer_thread.started.connect(self.installer_worker.run)
self.installer_thread.start()
def install_finished(self):
# Process the result
self.progress_dialog.hide()
if self.installer_worker.install_status:
self.reload_collections_model()
message = '%s is installed successfully' % (
config.COLLECTIONS[self._selected_collection_id]['name'])
else:
message = self.installer_worker.error_message
QMessageBox.information(self, 'Resource Sharing', message)
# Clean up the worker and thread
self.installer_worker.deleteLater()
self.installer_thread.quit()
self.installer_thread.wait()
self.installer_thread.deleteLater()
def install_canceled(self):
self.progress_dialog.hide()
self.show_progress_dialog('Cancelling installation...')
self.installer_worker.abort()
def install_aborted(self):
if self.installer_thread.isRunning():
self.installer_thread.quit()
self.installer_thread.finished.connect(self.progress_dialog.hide)
def install_progress(self, text):
self.progress_dialog.setLabelText(text)
def uninstall_collection(self):
"""Slot called when user clicks uninstall button."""
try:
self.collection_manager.uninstall(self._selected_collection_id)
except Exception as e:
raise
self.reload_collections_model()
QMessageBox.information(
self,
'Resource Sharing',
'The collection is uninstalled succesfully!')
def open_collection(self):
"""Slot for when user clicks 'Open' button."""
collection_path = local_collection_path(self._selected_collection_id)
directory_url = QUrl.fromLocalFile(collection_path)
QDesktopServices.openUrl(directory_url)
def reload_data_and_widget(self):
"""Reload repositories and collections and update widgets related."""
self.reload_repositories_widget()
self.reload_collections_model()
def reload_repositories_widget(self):
"""Refresh tree repositories using new repositories data."""
self.repository_manager.load_directories()
self.populate_repositories_widget()
def populate_repositories_widget(self):
"""Populate the current dictionary repositories to the tree widget."""
# Clear the current tree widget
self.tree_repositories.clear()
# Export the updated ones from the repository manager
for repo_name in self.repository_manager.directories:
url = self.repository_manager.directories[repo_name]['url']
item = QTreeWidgetItem(self.tree_repositories)
item.setText(0, repo_name)
item.setText(1, url)
self.tree_repositories.resizeColumnToContents(0)
self.tree_repositories.resizeColumnToContents(1)
self.tree_repositories.sortItems(1, Qt.AscendingOrder)
def reload_collections_model(self):
"""Reload the collections model with the current collections."""
self.collections_model.clear()
for id in config.COLLECTIONS:
collection_name = config.COLLECTIONS[id]['name']
collection_author = config.COLLECTIONS[id]['author']
collection_tags = config.COLLECTIONS[id]['tags']
collection_description = config.COLLECTIONS[id]['description']
collection_status = config.COLLECTIONS[id]['status']
item = QStandardItem(collection_name)
item.setEditable(False)
item.setData(id, COLLECTION_ID_ROLE)
item.setData(collection_name, COLLECTION_NAME_ROLE)
item.setData(collection_description, COLLECTION_DESCRIPTION_ROLE)
item.setData(collection_author, COLLECTION_AUTHOR_ROLE)
item.setData(collection_tags, COLLECTION_TAGS_ROLE)
item.setData(collection_status, COLLECTION_STATUS_ROLE)
self.collections_model.appendRow(item)
self.collections_model.sort(0, Qt.AscendingOrder)
def on_tree_repositories_itemSelectionChanged(self):
"""Slot for when the itemSelectionChanged signal emitted."""
# Activate edit and delete button
self.button_edit.setEnabled(True)
self.button_delete.setEnabled(True)
def on_list_view_collections_clicked(self, index):
"""Slot for when the list_view_collections is clicked."""
real_index = self.collection_proxy.mapToSource(index)
if real_index.row() != -1:
collection_item = self.collections_model.itemFromIndex(real_index)
collection_id = collection_item.data(COLLECTION_ID_ROLE)
self._selected_collection_id = collection_id
# Enable/disable button
status = config.COLLECTIONS[self._selected_collection_id]['status']
is_installed = status == COLLECTION_INSTALLED_STATUS
if is_installed:
self.button_install.setEnabled(True)
self.button_install.setText('Reinstall')
self.button_open.setEnabled(True)
self.button_uninstall.setEnabled(True)
else:
self.button_install.setEnabled(True)
self.button_install.setText('Install')
self.button_open.setEnabled(False)
self.button_uninstall.setEnabled(False)
# Show metadata
self.show_collection_metadata(collection_id)
@pyqtSlot(str)
def filter_collections(self, text):
search = QRegExp(
text,
Qt.CaseInsensitive,
QRegExp.RegExp)
self.collection_proxy.setFilterRegExp(search)
def show_collection_metadata(self, id):
"""Show the collection metadata given the id."""
html = self.collection_manager.get_html(id)
self.web_view_details.setHtml(html)
def reject(self):
"""Slot when the dialog is closed."""
# Serialize collections to settings
self.repository_manager.serialize_repositories()
self.done(0)
def open_help(self):
"""Open help."""
doc_url = QUrl('http://www.akbargumbira.com/qgis_resources_sharing')
QDesktopServices.openUrl(doc_url)
def show_progress_dialog(self, text):
"""Show infinite progress dialog with given text.
:param text: Text as the label of the progress dialog
:type text: str
"""
if self.progress_dialog is None:
self.progress_dialog = QProgressDialog(self)
self.progress_dialog.setWindowModality(Qt.WindowModal)
self.progress_dialog.setAutoClose(False)
title = self.tr('Resource Sharing')
self.progress_dialog.setWindowTitle(title)
# Just use infinite progress bar here
self.progress_dialog.setMaximum(0)
self.progress_dialog.setMinimum(0)
self.progress_dialog.setValue(0)
self.progress_dialog.setLabelText(text)
self.progress_dialog.show()
class SchematisationLoad(uicls, basecls):
"""Dialog for local schematisation loading."""
def __init__(self, plugin_dock, parent=None):
super().__init__(parent)
self.setupUi(self)
self.plugin_dock = plugin_dock
self.working_dir = self.plugin_dock.plugin_settings.working_dir
self.communication = self.plugin_dock.communication
self.local_schematisations = list_local_schematisations(
self.working_dir)
self.tv_schematisations_model = QStandardItemModel()
self.schematisations_tv.setModel(self.tv_schematisations_model)
self.tv_revisions_model = QStandardItemModel()
self.revisions_tv.setModel(self.tv_revisions_model)
self.selected_local_schematisation = None
self.pb_load.clicked.connect(self.load_local_schematisation)
self.pb_cancel.clicked.connect(self.cancel_load_local_schematisation)
self.schematisations_tv.selectionModel().selectionChanged.connect(
self.populate_local_schematisation_revisions)
self.revisions_tv.selectionModel().selectionChanged.connect(
self.toggle_load_local_schematisation)
self.populate_local_schematisations()
def populate_local_schematisations(self):
"""Populate local schematisations."""
self.tv_revisions_model.clear()
self.tv_schematisations_model.clear()
header = ["Schematisation name", "Schematisation ID", "Absolute path"]
self.tv_schematisations_model.setHorizontalHeaderLabels(header)
for schematisation_id, local_schematisation in self.local_schematisations.items(
):
name_item = QStandardItem(local_schematisation.name)
name_item.setData(local_schematisation, role=Qt.UserRole)
id_item = QStandardItem(str(schematisation_id))
dir_item = QStandardItem(local_schematisation.main_dir)
self.tv_schematisations_model.appendRow(
[name_item, id_item, dir_item])
for i in range(len(header)):
self.schematisations_tv.resizeColumnToContents(i)
def populate_local_schematisation_revisions(self):
"""Populate local schematisation revisions."""
self.tv_revisions_model.clear()
header = ["Revision number", "Subdirectory"]
self.tv_revisions_model.setHorizontalHeaderLabels(header)
local_schematisation = self.get_selected_local_schematisation()
wip_revision = local_schematisation.wip_revision
if wip_revision is not None:
number_item = QStandardItem(str(wip_revision.number))
number_item.setData(wip_revision, role=Qt.UserRole)
subdir_item = QStandardItem(wip_revision.sub_dir)
self.tv_revisions_model.appendRow([number_item, subdir_item])
for revision_number, local_revision in reversed(
local_schematisation.revisions.items()):
number_item = QStandardItem(str(revision_number))
number_item.setData(local_revision, role=Qt.UserRole)
subdir_item = QStandardItem(local_revision.sub_dir)
self.tv_revisions_model.appendRow([number_item, subdir_item])
for i in range(len(header)):
self.schematisations_tv.resizeColumnToContents(i)
if self.tv_revisions_model.rowCount() > 0:
row_idx = self.tv_revisions_model.index(0, 0)
self.revisions_tv.selectionModel().setCurrentIndex(
row_idx, QItemSelectionModel.ClearAndSelect)
self.toggle_load_local_schematisation()
def toggle_load_local_schematisation(self):
"""Toggle load button if any schematisation revision is selected."""
selection_model = self.revisions_tv.selectionModel()
if selection_model.hasSelection():
self.pb_load.setEnabled(True)
else:
self.pb_load.setDisabled(True)
def get_selected_local_schematisation(self):
"""Get currently selected local schematisation."""
index = self.schematisations_tv.currentIndex()
if index.isValid():
current_row = index.row()
name_item = self.tv_schematisations_model.item(current_row, 0)
local_schematisation = name_item.data(Qt.UserRole)
else:
local_schematisation = None
return local_schematisation
def get_selected_local_revision(self):
"""Get currently selected local revision."""
index = self.revisions_tv.currentIndex()
if index.isValid():
current_row = index.row()
name_item = self.tv_revisions_model.item(current_row, 0)
local_revision = name_item.data(Qt.UserRole)
else:
local_revision = None
return local_revision
def load_local_schematisation(self):
"""Loading selected local schematisation."""
local_schematisation = self.get_selected_local_schematisation()
local_revision = self.get_selected_local_revision()
if not isinstance(local_revision, WIPRevision):
title = "Pick action"
question = f"Replace WIP with data from the revision {local_revision.number}?"
picked_action_name = self.communication.custom_ask(
self, title, question, "Replace", "Cancel")
if picked_action_name == "Replace":
wip_revision = local_schematisation.set_wip_revision(
local_revision.number)
replace_revision_data(local_revision, wip_revision)
else:
local_schematisation = None
self.selected_local_schematisation = local_schematisation
self.close()
def cancel_load_local_schematisation(self):
"""Cancel local schematisation loading."""
self.close()
class QRiSDockWidget(QtWidgets.QDockWidget, FORM_CLASS):
closingPlugin = pyqtSignal()
def __init__(self, parent=None):
"""Constructor."""
super(QRiSDockWidget, self).__init__(parent)
# Set up the user interface from Designer.
# After setupUI you can access any designer object by doing
# self.<objectname>, and you can use autoconnect slots - see
# http://doc.qt.io/qt-5/designer-using-a-ui-file.html
# #widgets-and-dialogs-with-auto-connect
self.setupUi(self)
self.settings = Settings()
self.qris_project = None
self.menu = ContextMenu()
self.treeView.setContextMenuPolicy(Qt.CustomContextMenu)
self.treeView.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.treeView.customContextMenuRequested.connect(self.open_menu)
# self.treeView.doubleClicked.connect(self.default_tree_action)
# self.treeView.clicked.connect(self.item_change)
# self.treeView.expanded.connect(self.expand_tree_item)
self.model = QStandardItemModel()
self.treeView.setModel(self.model)
# Take this out of init so that nodes can be added as new data is added and imported;
def build_tree_view(self, qris_project, new_item=None):
"""Builds items in the tree view based on dictionary values that are part of the project"""
self.qris_project = qris_project
self.model.clear()
self.tree_state = {}
rootNode = self.model.invisibleRootItem()
# set the project root
project_node = QStandardItem(self.qris_project.project_name)
project_node.setIcon(QIcon(':/plugins/qris_toolbar/icon.png'))
project_node.setData('project_root', item_code['item_type'])
rootNode.appendRow(project_node)
self.treeView.setExpanded(project_node.index(), True)
# Add project extent layers to tree
extent_folder = QStandardItem("Project Extents")
extent_folder.setIcon(QIcon(':/plugins/qris_toolbar/test_folder.png'))
extent_folder.setData('extent_folder', item_code['item_type'])
project_node.appendRow(extent_folder)
for extent in self.qris_project.project_extents.values():
extent_node = QStandardItem(extent.display_name)
extent_node.setIcon(
QIcon(':/plugins/qris_toolbar/test_project_extent.png'))
extent_node.setData('extent_node', item_code['item_type'])
extent_node.setData(extent, item_code['INSTANCE'])
extent_folder.appendRow(extent_node)
# Add project layers node
layers_folder = QStandardItem("Project Layers")
layers_folder.setIcon(QIcon(':/plugins/qris_toolbar/test_folder.png'))
layers_folder.setData('layers_folder', item_code['item_type'])
project_node.appendRow(layers_folder)
# TODO extend this for geometry types and raster layers
for layer in self.qris_project.project_vector_layers.values():
layer_node = QStandardItem(layer.display_name)
# TODO change icon by type
layer_node.setIcon(QIcon(':/plugins/qris_toolbar/test_layers.png'))
layer_node.setData('layer_node', item_code['item_type'])
layer_node.setData(layer, item_code['INSTANCE'])
layers_folder.appendRow(layer_node)
# # Add riverscape surfaces node
# # TODO go through and add layers to the tree
# riverscape_surfaces_node = QStandardItem("Riverscape Surfaces")
# riverscape_surfaces_node.setIcon(QIcon(':/plugins/qris_toolbar/BrowseFolder.png'))
# riverscape_surfaces_node.setData('riverscape_surfaces_folder', item_code['item_type'])
# riverscape_surfaces_node.setData('group', item_code['item_layer'])
# project_node.appendRow(riverscape_surfaces_node)
# # Add riverscape segments node
# # TODO go through and add layers to the tree
# riverscape_segments_node = QStandardItem("Riverscape Segments")
# riverscape_segments_node.setIcon(QIcon(':/plugins/qris_toolbar/BrowseFolder.png'))
# riverscape_segments_node.setData('riverscape_segments_folder', item_code['item_type'])
# riverscape_segments_node.setData('group', item_code['item_layer'])
# project_node.appendRow(riverscape_segments_node)
# # Add detrended rasters to tree
# detrended_rasters = QStandardItem("Detrended Rasters")
# detrended_rasters.setIcon(QIcon(':/plugins/qris_toolbar/BrowseFolder.png'))
# detrended_rasters.setData("DetrendedRastersFolder", item_code['item_type'])
# detrended_rasters.setData('group', item_code['item_layer'])
# project_node.appendRow(detrended_rasters)
# for raster in self.qris_project.detrended_rasters.values():
# detrended_raster = QStandardItem(raster.name)
# detrended_raster.setIcon(QIcon(':/plugins/qris_toolbar/qris_raster.png'))
# detrended_raster.setData('DetrendedRaster', item_code['item_type'])
# detrended_raster.setData(raster, item_code['INSTANCE'])
# detrended_raster.setData('raster_layer', item_code['item_layer'])
# detrended_rasters.appendRow(detrended_raster)
# if len(raster.surfaces.values()) > 0:
# item_surfaces = QStandardItem("Surfaces")
# item_surfaces.setIcon(QIcon(':/plugins/qris_toolbar/BrowseFolder.png'))
# item_surfaces.setData('group', item_code['item_layer'])
# detrended_raster.appendRow(item_surfaces)
# for surface in raster.surfaces.values():
# item_surface = QStandardItem(surface.name)
# item_surface.setIcon(QIcon(':/plugins/qris_toolbar/layers/Polygon.png'))
# item_surface.setData('DetrendedRasterSurface', item_code['item_type'])
# item_surface.setData('surface_layer', item_code['item_layer'])
# item_surface.setData(surface, item_code['INSTANCE'])
# item_surfaces.appendRow(item_surface)
# # Add assessments to tree
# assessments_parent_node = QStandardItem("Riverscape Assessments")
# assessments_parent_node.setIcon(QIcon(':/plugins/qris_toolbar/BrowseFolder.png'))
# assessments_parent_node.setData('assessments_folder', item_code['item_type'])
# assessments_parent_node.setData('group', item_code['item_layer'])
# project_node.appendRow(assessments_parent_node)
# if self.qris_project.project_assessments:
# self.qris_project.assessments_path = os.path.join(self.qris_project.project_path, "Assessments.gpkg")
# assessments_layer = QgsVectorLayer(self.qris_project.assessments_path + "|layername=assessments", "assessments", "ogr")
# for assessment_feature in assessments_layer.getFeatures():
# assessment_node = QStandardItem(assessment_feature.attribute('assessment_date').toString('yyyy-MM-dd'))
# assessment_node.setIcon(QIcon(':/plugins/qris_toolbar/BrowseFolder.png'))
# assessment_node.setData('dam_assessment', item_code['item_type'])
# assessment_node.setData('group', item_code['item_layer'])
# assessment_node.setData(assessment_feature.attribute('fid'), item_code['feature_id'])
# assessments_parent_node.appendRow(assessment_node)
# assessments_parent_node.sortChildren(Qt.AscendingOrder)
# Add designs to tree
design_folder = QStandardItem("Low-Tech Designs")
design_folder.setIcon(QIcon(':/plugins/qris_toolbar/test_folder.png'))
design_folder.setData('design_folder', item_code['item_type'])
project_node.appendRow(design_folder)
self.treeView.setExpanded(design_folder.index(), True)
design_geopackage_path = self.qris_project.project_designs.geopackage_path(
self.qris_project.project_path)
designs_path = design_geopackage_path + '|layername=designs'
if os.path.exists(design_geopackage_path):
designs_layer = QgsVectorLayer(designs_path, "designs", "ogr")
for design_feature in designs_layer.getFeatures():
# If these data types stick this should be refactored into a create node function
design_node = QStandardItem(design_feature.attribute('name'))
design_node.setIcon(
QIcon(':/plugins/qris_toolbar/test_design.png'))
design_node.setData('design', item_code['item_type'])
design_node.setData(design_feature.attribute('fid'),
item_code['feature_id'])
design_folder.appendRow(design_node)
# TODO add the structure, footprint, and zoi to the tree under each design
# TODO This just doesn't work very well
design_folder.sortChildren(Qt.AscendingOrder)
# populate structure types
structure_type_folder = QStandardItem("Structure Types")
structure_type_folder.setIcon(
QIcon(':/plugins/qris_toolbar/test_settings.png'))
structure_type_folder.setData('structure_type_folder',
item_code['item_type'])
design_folder.appendRow(structure_type_folder)
structure_type_path = design_geopackage_path + '|layername=structure_types'
structure_type_layer = QgsVectorLayer(structure_type_path,
"structure_types", "ogr")
for structure_type in structure_type_layer.getFeatures():
structure_type_node = QStandardItem(
structure_type.attribute('name'))
# TODO change the icon
structure_type_node.setIcon(
QIcon(':/plugins/qris_toolbar/test_structure.png'))
structure_type_node.setData('structure_type',
item_code['item_type'])
structure_type_node.setData(structure_type.attribute('fid'),
item_code['feature_id'])
structure_type_folder.appendRow(structure_type_node)
# populate design phases types
phase_folder = QStandardItem("Implementation Phases")
# TODO change icon
phase_folder.setIcon(QIcon(':/plugins/qris_toolbar/test_settings.png'))
phase_folder.setData('phase_folder', item_code['item_type'])
design_folder.appendRow(phase_folder)
phase_path = design_geopackage_path + '|layername=phases'
phase_layer = QgsVectorLayer(phase_path, "phases", "ogr")
for phase in phase_layer.getFeatures():
phase_node = QStandardItem(phase.attribute('name'))
# TODO change the icon
phase_node.setIcon(QIcon(':/plugins/qris_toolbar/test_phase.png'))
phase_node.setData('phase', item_code['item_type'])
phase_node.setData(phase.attribute('fid'), item_code['feature_id'])
phase_folder.appendRow(phase_node)
# populate zoi types
zoi_type_folder = QStandardItem("ZOI Types")
zoi_type_folder.setIcon(
QIcon(':/plugins/qris_toolbar/test_settings.png'))
zoi_type_folder.setData('zoi_type_folder', item_code['item_type'])
design_folder.appendRow(zoi_type_folder)
zoi_type_path = design_geopackage_path + '|layername=zoi_types'
zoi_type_layer = QgsVectorLayer(zoi_type_path, "zoi_types", "ogr")
for zoi_type in zoi_type_layer.getFeatures():
zoi_type_node = QStandardItem(zoi_type.attribute('name'))
# TODO change the icon
zoi_type_node.setIcon(
QIcon(':/plugins/qris_toolbar/test_influence.png'))
zoi_type_node.setData('zoi_type', item_code['item_type'])
zoi_type_node.setData(zoi_type.attribute('fid'),
item_code['feature_id'])
zoi_type_folder.appendRow(zoi_type_node)
# Add a placed for photos
# photos_folder = QStandardItem("Project Photos")
# photos_folder.setIcon(QIcon(':/plugins/qris_toolbar/BrowseFolder.png'))
# photos_folder.setData('photos_folder', item_code['item_type'])
# project_node.appendRow(photos_folder)
# TODO for now we are expanding the map however need to remember expanded state or add new nodes as we add data
# self.treeView.expandAll()
# Check if new item is in the tree, if it is pass it to the add_to_map function
# Adds a test comment
if new_item is not None and new_item != '':
selected_item = self._find_item_in_model(new_item)
if selected_item is not None:
add_to_map(self.qris_project, self.model, selected_item)
def _find_item_in_model(self, name):
"""Looks in the tree for an item name passed from the dataChange method."""
# TODO may want to pass this is a try except block and give an informative error message
selected_item = self.model.findItems(name, Qt.MatchRecursive)[0]
return selected_item
def get_item_expanded_state(self):
"""Recursively records a list of the expanded state for items in the tree"""
def closeEvent(self, event):
self.qris_project = None
self.closingPlugin.emit()
event.accept()
def open_menu(self, position):
"""Connects signals as context menus to items in the tree"""
self.menu.clear()
indexes = self.treeView.selectedIndexes()
if len(indexes) < 1:
return
# No multiselect so there is only ever one item
idx = indexes[0]
if not idx.isValid():
return
model_item = self.model.itemFromIndex(indexes[0])
item_type = model_item.data(item_code['item_type'])
if item_type == 'project_root':
self.menu.addAction('EXPAND_ALL', lambda: self.expand_tree())
self.menu.addAction('COLLAPSE_ALL', lambda: self.collapse_tree())
self.menu.addAction(
'REFRESH_TREE',
lambda: self.build_tree_view(self.qris_project, None))
elif item_type == "extent_folder":
self.menu.addAction('ADD_PROJECT_EXTENT_LAYER',
lambda: self.import_project_extent_layer())
self.menu.addAction('CREATE_BLANK_PROJECT_EXTENT_LAYER',
lambda: self.create_blank_project_extent())
elif item_type == "layers_folder":
self.menu.addAction('IMPORT_PROJECT_LAYER',
lambda: self.import_project_layer())
elif item_type == "layer_node":
self.menu.addAction(
'ADD_TO_MAP',
lambda: add_to_map(self.qris_project, self.model, model_item))
elif item_type in ['extent_node', 'Project_Extent']:
# self.menu.addAction('UPDATE_PROJECT_EXTENT', lambda: self.update_project_extent(model_item))
# self.menu.addAction('DELETE_PROJECT_EXTENT', lambda: self.delete_project_extent(model_item))
self.menu.addAction(
'ADD_TO_MAP',
lambda: add_to_map(self.qris_project, self.model, model_item))
elif item_type == "design_folder":
self.menu.addAction('ADD_DESIGN', lambda: self.add_design())
elif item_type == "design":
self.menu.addAction(
'ADD_TO_MAP_OR_UPDATE_SYMBOLOGY',
lambda: add_to_map(self.qris_project, self.model, model_item))
elif item_type == "structure_type_folder":
self.menu.addAction('ADD_STRUCTURE_TYPE',
lambda: self.add_structure_type())
elif item_type == "zoi_type_folder":
self.menu.addAction('ADD_ZOI_TYPE', lambda: self.add_zoi_type())
elif item_type == "phase_folder":
self.menu.addAction('ADD_PHASE', lambda: self.add_phase())
else:
self.menu.clear()
self.menu.exec_(self.treeView.viewport().mapToGlobal(position))
def expand_tree(self):
self.treeView.expandAll()
return
def collapse_tree(self):
self.treeView.collapseAll()
return
def add_assessment(self):
"""Initiates adding a new assessment"""
self.assessment_dialog = AssessmentDlg(self.qris_project)
self.assessment_dialog.dateEdit_assessment_date.setDate(
QDate.currentDate())
self.assessment_dialog.dataChange.connect(self.build_tree_view)
self.assessment_dialog.show()
def add_design(self):
"""Initiates adding a new design"""
self.design_dialog = DesignDlg(self.qris_project)
# TODO remove this stuff about date
self.design_dialog.dataChange.connect(self.build_tree_view)
self.design_dialog.show()
def add_structure_type(self):
"""Initiates adding a structure type and the structure type dialog"""
# TODO First check if the path to the database exists
design_geopackage_path = self.qris_project.project_designs.geopackage_path(
self.qris_project.project_path)
if os.path.exists(design_geopackage_path):
self.structure_type_dialog = StructureTypeDlg(self.qris_project)
self.structure_type_dialog.dataChange.connect(self.build_tree_view)
self.structure_type_dialog.show()
else:
# TODO move the creation of the design data model so that this isn't necessary
QMessageBox.information(
self, "Structure Types",
"Please create a new project design before adding structure types"
)
def add_zoi_type(self):
"""Initiates adding a zoi type and the zoi type dialog"""
# TODO First check if the path to the database exists
design_geopackage_path = self.qris_project.project_designs.geopackage_path(
self.qris_project.project_path)
if os.path.exists(design_geopackage_path):
self.zoi_type_dialog = ZoiTypeDlg(self.qris_project)
self.zoi_type_dialog.dataChange.connect(self.build_tree_view)
self.zoi_type_dialog.show()
else:
# TODO move the creation of the design data model so that this isn't necessary
QMessageBox.information(
self, "Structure Types",
"Please create a new project design before adding a new influence type"
)
def add_phase(self):
"""Initiates adding a new phase within the phase dialog"""
# TODO First check if the path to the database exists
design_geopackage_path = self.qris_project.project_designs.geopackage_path(
self.qris_project.project_path)
if os.path.exists(design_geopackage_path):
self.phase_dialog = PhaseDlg(self.qris_project)
self.phase_dialog.dataChange.connect(self.build_tree_view)
self.phase_dialog.show()
else:
# TODO move the creation of the design data model so that this isn't necessary
QMessageBox.information(
self, "Structure Types",
"Please create a new project design before adding phases")
# This will kick off importing photos
def import_photos(self):
pass
def add_detrended_raster(self):
# last_browse_path = self.settings.getValue('lastBrowsePath')
# last_dir = os.path.dirname(last_browse_path) if last_browse_path is not None else None
dialog_return = QFileDialog.getOpenFileName(
None, "Add Detrended Raster to QRiS project", None,
self.tr("Raster Data Sources (*.tif)"))
if dialog_return is not None and dialog_return[
0] != "" and os.path.isfile(dialog_return[0]):
self.addDetrendedDlg = AddDetrendedRasterDlg(
None, dialog_return[0], self.qris_project)
self.addDetrendedDlg.dataChange.connect(self.build_tree_view)
self.addDetrendedDlg.exec()
def import_project_extent_layer(self):
"""launches the dialog that supports import of a project extent layer polygon"""
select_layer = QgsDataSourceSelectDialog()
select_layer.exec()
uri = select_layer.uri()
if uri is not None and uri.isValid() and uri.wkbType == 3:
self.project_extent_dialog = ProjectExtentDlg(
uri, self.qris_project)
self.project_extent_dialog.dataChange.connect(self.build_tree_view)
self.project_extent_dialog.exec_()
else:
QMessageBox.critical(self, "Invalid Layer",
"Please select a valid polygon layer")
def create_blank_project_extent(self):
"""Adds a blank project extent that will be edited by the user"""
self.project_extent_dialog = ProjectExtentDlg(None, self.qris_project)
self.project_extent_dialog.dataChange.connect(self.build_tree_view)
self.project_extent_dialog.exec_()
def update_project_extent(self):
"""Renames the project extent layer"""
pass
# def delete_project_extent(self, selected_item):
# """Deletes a project extent layer"""
# display_name = selected_item.data(item_code['INSTANCE']).display_name
# feature_name = selected_item.data(item_code['INSTANCE']).feature_name
# geopackage_path = selected_item.data(item_code['INSTANCE']).geopackage_path(self.qris_project.project_path)
# delete_ok = QMessageBox.question(self, f"Delete extent", f"Are you f*****g sure you wanna delete the extent layer: {display_name}")
# if delete_ok == QMessageBox.Yes:
# # remove from the map if it's there
# # TODO consider doing this based on the path
# for layer in QgsProject.instance().mapLayers().values():
# if layer.name() == display_name:
# QgsProject.instance().removeMapLayers([layer.id()])
# iface.mapCanvas().refresh()
# # TODO be sure to test whether the table exists first
# gdal_delete = gdal.OpenEx(geopackage_path, gdal.OF_UPDATE, allowed_drivers=['GPKG'])
# error = gdal_delete.DeleteLayer(feature_name)
# gdal_delete.ExecuteSQL('VACUUM')
# # TODO remove this from the Extents dictionary that will also remove from promect xml
# del(self.qris_project.project_extents[feature_name])
# # refresh the project xml
# self.qris_project.write_project_xml()
# # refresh the tree
# self.build_tree_view(self.qris_project, None)
# else:
# QMessageBox.information(self, "Delete extent", "No layers were deleted")
def import_project_layer(self):
"""launches a dialog that supports import of project layers that can be clipped to a project extent"""
select_layer = QgsDataSourceSelectDialog()
select_layer.exec()
uri = select_layer.uri()
if uri is not None and uri.isValid(): # and uri.wkbType == 3:
self.project_layer_dialog = ProjectLayerDlg(uri, self.qris_project)
self.project_layer_dialog.dataChange.connect(self.build_tree_view)
self.project_layer_dialog.exec_()
else:
QMessageBox.critical(self, "Invalid Layer",
"Please select a valid gis layer")
def explore_elevations(self, selected_item):
raster = selected_item.data(item_code['INSTANCE'])
self.elevation_widget = ElevationDockWidget(raster, self.qris_project)
self.settings.iface.addDockWidget(Qt.LeftDockWidgetArea,
self.elevation_widget)
self.elevation_widget.dataChange.connect(self.build_tree_view)
self.elevation_widget.show()
class RuimtelijkePlannen(object):
"""QGIS Plugin Implementation."""
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 and the mapCanvas
self.iface = iface
self.mapcanvas = iface.mapCanvas()
# initialize plugin directory
self.plugin_dir = os.path.dirname(__file__)
# initialize locale
if not QSettings().value('locale/userLocale'):
locale = QSettings().value('locale/globalLocale')[0:2]
else:
locale = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(self.plugin_dir, 'i18n',
'RuimtelijkePlannen_{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
# Declare instance attributes
self.actions = []
self.menu = self.tr(u'&Ruimtelijke Plannen')
self.toolbar = self.iface.addToolBar(u'RuimtelijkePlannen')
self.toolbar.setObjectName(u'RuimtelijkePlannen')
self.nam = networkaccessmanager.NetworkAccessManager()
self.project = QgsProject.instance()
# initialize styles folder
self.settings = QSettings()
self.available_styles_folder = os.path.join(self.plugin_dir, 'styles')
self.map_style = self.settings.value("RuimtelijkePlannen/map_style",
"print")
self.map_style_folder = os.path.join(self.available_styles_folder,
self.map_style)
if not os.path.isdir(self.map_style_folder):
self.map_style = "print"
self.map_style_folder = os.path.join(self.available_styles_folder,
self.map_style)
def tr(self, message):
"""Get the translation for a string using Qt translation API.
We implement this ourselves since we do not inherit QObject.
:param message: String for translation.
:type message: str, QString
:returns: Translated version of message.
:rtype: QString
"""
return QCoreApplication.translate('RuimtelijkePlannen', message)
def add_action(self,
dialog,
icon_path,
text,
callback,
enabled_flag=True,
add_to_menu=True,
add_to_toolbar=True,
status_tip=None,
whats_this=None,
parent=None):
"""Add a toolbar icon to the toolbar.
:param icon_path: Path to the icon for this action. Can be a resource
path (e.g. ':/plugins/foo/bar.png') or a normal file system path.
:type icon_path: str
:param text: Text that should be shown in menu items for this action.
:type text: str
:param callback: Function to be called when the action is triggered.
:type callback: function
:param enabled_flag: A flag indicating if the action should be enabled
by default. Defaults to True.
:type enabled_flag: bool
:param add_to_menu: Flag indicating whether the action should also
be added to the menu. Defaults to True.
:type add_to_menu: bool
:param add_to_toolbar: Flag indicating whether the action should also
be added to the toolbar. Defaults to True.
:type add_to_toolbar: bool
:param status_tip: Optional text to show in a popup when mouse pointer
hovers over the action.
:type status_tip: str
:param parent: Parent widget for the new action. Defaults None.
:type parent: QWidget
:param whats_this: Optional text to show in the status bar when the
mouse pointer hovers over the action.
:returns: The action that was created. Note that the action is also
added to self.actions list.
:rtype: QAction
"""
if dialog:
self.dlg = dialog
icon = QIcon(icon_path)
action = QAction(icon, text, parent)
action.triggered.connect(callback)
action.setEnabled(enabled_flag)
if status_tip is not None:
action.setStatusTip(status_tip)
if whats_this is not None:
action.setWhatsThis(whats_this)
if add_to_toolbar:
self.toolbar.addAction(action)
if add_to_menu:
self.iface.addPluginToWebMenu(self.menu, action)
self.actions.append(action)
return action
def initGui(self):
"""Create the menu entries and toolbar icons inside the QGIS GUI."""
self.dlg = RuimtelijkePlannenDialog()
self.settings_dlg = RuimtelijkePlannenSettingsDialog()
self.add_action(dialog=None,
icon_path=':/plugins/RuimtelijkePlannen/help.png',
text=self.tr(u'Help'),
callback=self.open_help,
parent=self.iface.mainWindow(),
add_to_toolbar=False)
self.add_action(dialog=None,
icon_path=':/plugins/RuimtelijkePlannen/settings.png',
text=self.tr(u'Settings'),
callback=self.run_settings,
parent=self.iface.mainWindow(),
add_to_toolbar=False)
# add a button to click in map and find bestemmingsplannen
self.action = self.add_action(
dialog=None,
icon_path=':/plugins/RuimtelijkePlannen/icon.png',
text=self.tr(u'Click map query RuimtelijkePlannen'),
callback=self.activate_tool,
add_to_menu=True,
status_tip=self.tr(u'Click map query RuimtelijkePlannen'),
parent=self.iface.mainWindow())
self.action.setCheckable(True)
# add it to the same group as the pan/zoom tools
self.iface.actionPan().actionGroup().addAction(self.action)
self.xytool = GetPointTool(self.mapcanvas, self.getRPplannenByPoint)
self.toolbarSearch = QLineEdit()
self.toolbarSearch.setMaximumWidth(200)
self.toolbarSearch.setAlignment(QtCore.Qt.AlignLeft)
self.toolbarSearch.setPlaceholderText("NL.IMRO.")
self.toolbar.addWidget(self.toolbarSearch)
self.toolbarSearch.returnPressed.connect(self.addRPplanFromToolbar)
self.proxyModel = QSortFilterProxyModel()
self.sourceModel = QStandardItemModel()
self.proxyModel.setSourceModel(self.sourceModel)
self.dlg.treeView_results.setModel(self.proxyModel)
self.dlg.treeView_results.setEditTriggers(
QAbstractItemView.NoEditTriggers)
self.dlg.treeView_results.setSortingEnabled(True)
self.dlg.treeView_results.doubleClicked.connect(self.loadRPplan)
# have an info icon at hand for keuzehulp
self.infoIcon = QIcon(':/plugins/RuimtelijkePlannen/info.png')
# have the right crs at hand
self.rp_crs = QgsCoordinateReferenceSystem(28992)
## urls to RuimtelijkePlannen
## this one is the traditional one
# self.rp_search_url = "https://www.ruimtelijkeplannen.nl/web-roo/rest/search"
# self.rp_search_id_resource = "/plan/id/"
# self.rp_search_xy_resource = "/plannen/xy/"
## this one is new and has more metadata with the "keuzehulp"!
self.rp_search_url = "https://www.ruimtelijkeplannen.nl/plannenservice"
self.rp_search_id_resource = "/plannen/identificatie/"
self.rp_search_xy_resource = "/plannen/xy/"
self.rp_wfs_url = "https://afnemers.ruimtelijkeplannen.nl/afnemers2012/services"
# the following lists of plantypes comes from:
# https://www.ruimtelijkeplannen.nl/viewer/planoverzicht
self.rp_supported_planTypes = [\
'aanwijzingsbesluit',
'beheersverordening',
'bestemmingsplan',
'exploitatieplan',
'gemeentelijk plan; bestemmingsplan artikel 10',
'gemeentelijk plan; uitwerkingsplan artikel 11',
'gemeentelijk plan; voorbereidingsbesluit',
'gemeentelijk plan; wijzigingsplan artikel 11',
'gemeentelijke visie; overig',
'gerechtelijke uitspraak',
'inpassingsplan',
'omgevingsvergunning',
'projectbesluit',
'reactieve aanwijzing',
'tijdelijke ontheffing buitenplans',
'uitwerkingsplan',
'voorbereidingsbesluit',
'wijzigingsplan'
]
self.rp_not_supported_plantypes = [\
# these are the plan types which can have multiple maps
'amvb',
'provinciale verordening',
'regeling',
'structuurvisie'
]
# layer action on RuimtelijkePlannen layers to show links to text
self.rp_layer_action = QgsAction(QgsAction.GenericPython,
'Open text link(s) in browser ',
layer_action, "", False, "",
{'Feature', 'Canvas'})
def unload(self):
"""Removes the plugin menu item and icon from QGIS GUI."""
for action in self.actions:
self.iface.removePluginWebMenu(self.tr(u'&Ruimtelijke Plannen'),
action)
self.iface.removeToolBarIcon(action)
del self.toolbar
def open_help(self):
'''
Method to open the help pages
'''
QDesktopServices().openUrl(
QUrl.fromLocalFile(
os.path.join("file://", self.plugin_dir, 'help/build/html',
'index.html')))
def run_settings(self):
'''
method showing the settings dialog and act on the results
'''
# we do this on opening this setting, so the user can easily add
# new styles wthout reloading the plugin.
available_styles = next(os.walk(self.available_styles_folder))[1]
self.settings_dlg.styleComboBox.clear()
self.settings_dlg.styleComboBox.addItems(available_styles)
index = self.settings_dlg.styleComboBox.findText(self.map_style)
self.settings_dlg.styleComboBox.setCurrentIndex(index)
self.settings_dlg.show()
result = self.settings_dlg.exec_()
if result:
map_style_folder = os.path.join(
self.available_styles_folder,
self.settings_dlg.styleComboBox.currentText())
if os.path.isdir(map_style_folder):
self.map_style = self.settings_dlg.styleComboBox.currentText()
self.map_style_folder = os.path.join(
self.available_styles_folder, self.map_style)
self.settings.setValue("RuimtelijkePlannen/map_style",
self.map_style)
else:
self.iface.messageBar().pushMessage(
'Warning',
self.
tr(u"Selected style folder not found. See message log for details."
),
level=Qgis.Warning)
QgsMessageLog.logMessage(u'Style folder not found: ' + \
os.path.join(self.available_styles_folder, self.map_style),
'RuimtelijkePlannen')
def activate_tool(self):
self.mapcanvas.setMapTool(self.xytool)
def addRPplanFromToolbar(self):
'''slot for toolbarSearch'''
self.addFromIdn(self.toolbarSearch.text())
def addFromIdn(self, search_string):
'''adds plan from idn'''
self.toolbarSearch.clear()
url = self.rp_search_url + self.rp_search_id_resource + search_string
QgsMessageLog.logMessage(u'Query: ' + str(url), 'RuimtelijkePlannen')
QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)
(response, content) = self.nam.request(url)
self.rp = json.loads(content.decode("utf-8"))
QApplication.restoreOverrideCursor()
if "ErrorType" in self.rp \
or ('aantal' in self.rp and self.rp['aantal'] == 0):
self.iface.messageBar().pushMessage("Error",
self.tr(u'Plan not found.'),
level=Qgis.Critical)
return
if 'resultaat' in self.rp:
# we are using the keuzeHulp
self.rp = self.rp['plannen'][0]
if not self.rp["typePlan"] in self.rp_supported_planTypes:
self.iface.messageBar().pushMessage(
"Error",
self.tr(u'Plan type not supported.'),
level=Qgis.Critical)
else:
self.addRPplan_WFS(plangebied=search_string,
plantype=self.rp["typePlan"])
def getWfsLayer(self, service, typename, wfs_filter):
params = {
'service': 'WFS',
'version': '1.1.0',
'request': 'GetFeature',
'typename': typename,
'filter': wfs_filter,
'srsname': 'EPSG:28992',
}
if not service[-1] == '?':
service += '?'
uri = service + urllib.parse.unquote(urllib.parse.urlencode(params))
layername = typename
vlayer = QgsVectorLayer(uri, layername, "WFS")
return vlayer
def addRPplan_WFS(self, plangebied, plantype):
'''adds a plan as a WFS layer'''
QgsMessageLog.logMessage(u'Adding plan with IDN "%s" and plantype "%s"'\
% (plangebied,plantype), 'RuimtelijkePlannen')
# add a layergroup to insert the layers in
bpGroup = QgsProject.instance().layerTreeRoot().insertGroup(
0, plangebied)
service = self.rp_wfs_url
wfs_filter = '"plangebied"=\'' + plangebied + '\''
plan = rp_plan(plantype)
for layer in plan.layers:
vlayer = self.getWfsLayer(service, layer['name'], wfs_filter)
if vlayer.isValid():
if 'qml' in layer:
layerQml = os.path.join(self.map_style_folder,
layer['qml'])
if os.path.exists(layerQml):
vlayer.loadNamedStyle(layerQml)
else:
self.iface.messageBar().pushMessage(
'Warning',
self.
tr(u"Style not found. See message log for details."
),
level=Qgis.Warning)
QgsMessageLog.logMessage(u'Style file not found: ' + \
str(layerQml), 'RuimtelijkePlannen')
if layer['text_action']:
vlayer.actions().addAction(self.rp_layer_action)
self.project.addMapLayer(vlayer, False)
bpGroup.insertChildNode(-1, QgsLayerTreeLayer(vlayer))
else:
self.iface.messageBar().pushMessage(
'Warning',
self.tr(u"Invalid layer: ") + layer['name'],
level=Qgis.Warning)
vlayer.selectAll()
canvas = self.iface.mapCanvas()
canvas.zoomToSelected(vlayer)
vlayer.removeSelection()
def loadRPplan(self, index):
'''slot for row in search results widget'''
self.dlg.hide()
self.addRPplan_WFS(plangebied=index.sibling(index.row(), 1).data(),
plantype=index.sibling(index.row(), 3).data())
def addSourceRow(self, nr, plan, keuze_hulp=None):
'''adds plan to search results widget'''
if plan["typePlan"] in self.rp_supported_planTypes:
nr = QStandardItem(str(nr + 1))
planId = QStandardItem(plan["identificatie"])
if keuze_hulp:
planStatus = QStandardItem(self.infoIcon, plan["planStatus"])
f = planStatus.font()
f.setUnderline(True)
planStatus.setFont(f)
planStatus.setToolTip(
'%s: %s' %
(keuze_hulp["positieTekst"], keuze_hulp["keuzeHulpTekst"]))
else:
planStatus = QStandardItem(plan["planStatus"])
planNaam = QStandardItem(plan["naam"])
planType = QStandardItem(plan["typePlan"])
#planGebiedType = QStandardItem(plan["planGebiedType"])
# not yet(?) in use by this plugin
self.sourceModel.appendRow(
[nr, planId, planStatus, planType, planNaam])
def addSourceRowFromKeuzeHulp(self, nr, plan_en_keuze):
'''adds plan to search results widget'''
keuze_hulp = plan_en_keuze['keuzeHulp']
plan = plan_en_keuze['planDto']
self.addSourceRow(nr, plan, keuze_hulp)
def getRPplannenByPoint(self, event):
'''Queries ruimtelijkeplannen by point and shows results on widget.'''
xform = QgsCoordinateTransform(
self.mapcanvas.mapSettings().destinationCrs(), self.rp_crs,
QgsProject.instance())
xy = xform.transform(
QgsPointXY(
self.mapcanvas.getCoordinateTransform().toMapCoordinates(
event.pos().x(),
event.pos().y())))
self.sourceModel.clear()
url = self.rp_search_url + self.rp_search_xy_resource + str(
xy.x()) + "/" + str(xy.y())
QgsMessageLog.logMessage(u'Query: ' + str(url), 'RuimtelijkePlannen')
QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)
(response, content) = self.nam.request(url)
self.rp = json.loads(content.decode("utf-8"))
if "ErrorType" in self.rp:
self.iface.messageBar().pushMessage("Error",
self.tr(u'No Plans found.') +
self.rp["ErrorDescription"],
level=Qgis.Critical)
QApplication.restoreOverrideCursor()
return
if 'plannen' in self.rp:
for nr, plan in enumerate(self.rp["plannen"]):
self.addSourceRow(nr, plan)
else:
for nr, plan_en_keuze in enumerate(self.rp["keuzeHulpPlannen"]):
self.addSourceRowFromKeuzeHulp(nr, plan_en_keuze)
if not self.sourceModel.rowCount():
QApplication.restoreOverrideCursor()
return
self.sourceModel.setHeaderData(0, QtCore.Qt.Horizontal, "Nr")
self.sourceModel.setHeaderData(1, QtCore.Qt.Horizontal,
"Identification")
self.sourceModel.horizontalHeaderItem(1).setTextAlignment(
QtCore.Qt.AlignLeft)
self.sourceModel.setHeaderData(2, QtCore.Qt.Horizontal, "Status")
self.sourceModel.setHeaderData(3, QtCore.Qt.Horizontal, "Type")
self.sourceModel.setHeaderData(4, QtCore.Qt.Horizontal, "Name")
self.dlg.treeView_results.setColumnHidden(0, True)
self.dlg.treeView_results.resizeColumnsToContents()
self.dlg.treeView_results.horizontalHeader().setSectionResizeMode(
1, QHeaderView.Stretch)
self.dlg.treeView_results.setSelectionMode(1)
self.dlg.treeView_results.selectRow(0)
# sort on order of the keuzehulp, instead of status.
#self.dlg.treeView_results.sortByColumn(2, QtCore.Qt.AscendingOrder)
self.dlg.treeView_results.sortByColumn(0, QtCore.Qt.AscendingOrder)
QApplication.restoreOverrideCursor()
self.dlg.show()
class QQuakeDialog(QDialog, FORM_CLASS):
"""
The main plugin dialog
"""
def __init__(self, iface, parent=None): # pylint:disable=too-many-statements
"""Constructor."""
super().__init__(parent)
self.setupUi(self)
self.setObjectName('QQuakeDialog')
QgsGui.enableAutoGeometryRestore(self)
self.scrollArea.setStyleSheet("""
QScrollArea { background: transparent; }
QScrollArea > QWidget > QWidget { background: transparent; }
QScrollArea > QWidget > QScrollBar { background: 1; }
""")
self.scrollArea_2.setStyleSheet(self.scrollArea.styleSheet())
self.scrollArea_3.setStyleSheet(self.scrollArea.styleSheet())
self.scrollArea_4.setStyleSheet(self.scrollArea.styleSheet())
self.splitter.setStretchFactor(0, 0)
self.splitter_2.setStretchFactor(0, 0)
self.splitter_3.setStretchFactor(0, 0)
self.splitter_4.setStretchFactor(0, 0)
self.splitter.setStretchFactor(1, 1)
self.splitter_2.setStretchFactor(1, 1)
self.splitter_3.setStretchFactor(1, 1)
self.splitter_4.setStretchFactor(1, 1)
self.fdsn_event_filter = FilterParameterWidget(
iface, SERVICE_MANAGER.FDSNEVENT)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.fdsn_event_filter)
self.fdsn_event_filter_container.setLayout(vl)
self.earthquake_service_info_widget = ServiceInformationWidget(iface)
self.fdsn_by_id_filter = FilterByIdWidget(iface,
SERVICE_MANAGER.FDSNEVENT)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.fdsn_by_id_filter)
self.fdsn_by_id_container.setLayout(vl)
self.fdsn_by_url_widget = FetchByUrlWidget(iface,
SERVICE_MANAGER.FDSNEVENT)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.fdsn_by_url_widget)
self.fdsn_by_url_container.setLayout(vl)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.earthquake_service_info_widget)
self.earthquake_service_info_container.setLayout(vl)
self.macro_filter = FilterParameterWidget(iface,
SERVICE_MANAGER.MACROSEISMIC)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.macro_filter)
self.macro_filter_container.setLayout(vl)
self.macro_by_id_filter = FilterByIdWidget(
iface, SERVICE_MANAGER.MACROSEISMIC)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.macro_by_id_filter)
self.macro_by_id_container.setLayout(vl)
self.macro_by_url_widget = FetchByUrlWidget(
iface, SERVICE_MANAGER.MACROSEISMIC)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.macro_by_url_widget)
self.macro_by_url_container.setLayout(vl)
self.macro_service_info_widget = ServiceInformationWidget(iface)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.macro_service_info_widget)
self.macro_service_info_container.setLayout(vl)
self.station_filter = FilterParameterWidget(
iface, SERVICE_MANAGER.FDSNSTATION)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.station_filter)
self.station_filter_container.setLayout(vl)
self.station_by_id_filter = FilterStationByIdWidget(
iface, SERVICE_MANAGER.FDSNSTATION)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.station_by_id_filter)
self.station_by_id_container.setLayout(vl)
self.station_service_info_widget = ServiceInformationWidget(iface)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.station_service_info_widget)
self.station_service_info_container.setLayout(vl)
self.station_by_url_widget = FetchByUrlWidget(
iface, SERVICE_MANAGER.FDSNSTATION)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.station_by_url_widget)
self.station_by_url_container.setLayout(vl)
self.ogc_service_widget = OgcServiceWidget(iface)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.ogc_service_widget)
self.ogc_widget_container.setLayout(vl)
self.ogc_service_info_widget = ServiceInformationWidget(iface)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.ogc_service_info_widget)
self.ogc_service_info_container.setLayout(vl)
self.message_bar = QgsMessageBar()
self.message_bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.verticalLayout.insertWidget(0, self.message_bar)
self.fdsn_event_url_text_browser.viewport().setAutoFillBackground(
False)
self.fdsn_macro_url_text_browser.viewport().setAutoFillBackground(
False)
self.fdsn_station_url_text_browser.viewport().setAutoFillBackground(
False)
self.button_box.button(QDialogButtonBox.Ok).setText(
self.tr('Fetch Data'))
self.button_box.rejected.connect(self._save_settings)
self.iface = iface
# OGC
self.ogc_combo.addItem(self.tr('Web Map Services (WMS)'),
SERVICE_MANAGER.WMS)
self.ogc_combo.addItem(self.tr('Web Feature Services (WFS)'),
SERVICE_MANAGER.WFS)
self.ogc_combo.currentIndexChanged.connect(self.refreshOgcWidgets)
self.ogc_list_model = QStandardItemModel(self.ogc_list)
self.ogc_list.setModel(self.ogc_list_model)
self.ogc_list.selectionModel().selectionChanged.connect(
self._ogc_service_changed)
self._refresh_services()
SERVICE_MANAGER.refreshed.connect(self._refresh_services)
# connect to refreshing function to refresh the UI depending on the WS
self._refresh_fdsnevent_widgets()
self.refreshFdsnMacroseismicWidgets()
self.refreshFdsnStationWidgets()
# change the UI parameter according to the web service chosen
self.fdsn_event_list.currentRowChanged.connect(
self._refresh_fdsnevent_widgets)
self.fdsn_macro_list.currentRowChanged.connect(
self.refreshFdsnMacroseismicWidgets)
self.fdsn_station_list.currentRowChanged.connect(
self.refreshFdsnStationWidgets)
self.fdsn_event_filter.changed.connect(
lambda: self._refresh_url(SERVICE_MANAGER.FDSNEVENT))
self.fdsn_by_id_filter.changed.connect(
lambda: self._refresh_url(SERVICE_MANAGER.FDSNEVENT))
self.fdsn_by_url_widget.changed.connect(
lambda: self._refresh_url(SERVICE_MANAGER.FDSNEVENT))
self.fdsn_event_list.currentRowChanged.connect(
lambda: self._refresh_url(SERVICE_MANAGER.FDSNEVENT))
self.macro_filter.changed.connect(
lambda: self._refresh_url(SERVICE_MANAGER.MACROSEISMIC))
self.macro_by_id_filter.changed.connect(
lambda: self._refresh_url(SERVICE_MANAGER.MACROSEISMIC))
self.macro_by_url_widget.changed.connect(
lambda: self._refresh_url(SERVICE_MANAGER.MACROSEISMIC))
self.fdsn_macro_list.currentRowChanged.connect(
lambda: self._refresh_url(SERVICE_MANAGER.MACROSEISMIC))
self.station_filter.changed.connect(
lambda: self._refresh_url(SERVICE_MANAGER.FDSNSTATION))
self.station_by_id_filter.changed.connect(
lambda: self._refresh_url(SERVICE_MANAGER.FDSNSTATION))
self.fdsn_station_list.currentRowChanged.connect(
lambda: self._refresh_url(SERVICE_MANAGER.FDSNSTATION))
self.station_by_url_widget.changed.connect(
lambda: self._refresh_url(SERVICE_MANAGER.FDSNSTATION))
self.button_box.accepted.connect(self._getEventList)
self.service_tab_widget.currentChanged.connect(
lambda: self._refresh_url(None))
self.fetcher = None
QgsGui.enableAutoGeometryRestore(self)
self.fdsn_tab_widget.currentChanged.connect(
lambda: self._refresh_url(SERVICE_MANAGER.FDSNEVENT))
self.macro_tab_widget.currentChanged.connect(
lambda: self._refresh_url(SERVICE_MANAGER.MACROSEISMIC))
self.fdsnstation_tab_widget.currentChanged.connect(
lambda: self._refresh_url(SERVICE_MANAGER.FDSNSTATION))
for b in [
self.button_fdsn_new_service, self.button_macro_new_service,
self.button_station_new_service, self.button_ogc_new_service
]:
self._build_add_service_menu(b)
for b in [
self.button_fdsn_edit_service, self.button_macro_edit_service,
self.button_station_edit_service, self.button_ogc_edit_service
]:
b.clicked.connect(self._edit_service)
for b in [
self.button_fdsn_rename_service,
self.button_macro_rename_service,
self.button_station_rename_service,
self.button_ogc_rename_service
]:
b.clicked.connect(self._rename_service)
for b in [
self.button_fdsn_remove_service,
self.button_macro_remove_service,
self.button_station_remove_service,
self.button_ogc_remove_service
]:
b.clicked.connect(self._remove_service)
for b in [
self.button_fdsn_export_service,
self.button_macro_export_service,
self.button_station_export_service,
self.button_ogc_export_service
]:
b.clicked.connect(self._export_service)
self._restore_settings()
self._refresh_url(SERVICE_MANAGER.FDSNEVENT)
self._refresh_url(SERVICE_MANAGER.MACROSEISMIC)
self._refresh_url(SERVICE_MANAGER.FDSNSTATION)
def closeEvent(self, e): # pylint: disable=missing-function-docstring
self._save_settings()
super().closeEvent(e)
def _build_add_service_menu(self, widget):
"""
Builds the add service menu for a specific widget
"""
menu = QMenu()
save_action = QAction(self.tr('Save Current Configuration As…'),
parent=menu)
save_action.setObjectName('save_action')
menu.addAction(save_action)
save_action.triggered.connect(self._save_configuration)
import_action = QAction(self.tr('Import from File…'), parent=menu)
menu.addAction(import_action)
import_action.triggered.connect(self._import_configuration)
create_new_action = QAction(self.tr('Create New Service…'),
parent=menu)
menu.addAction(create_new_action)
create_new_action.triggered.connect(self._create_configuration)
menu.aboutToShow.connect(lambda: self._menu_about_to_show(menu))
widget.setMenu(menu)
def _menu_about_to_show(self, menu):
"""
Triggered when the Add Service menu is about to show
"""
save_current_action = menu.findChild(QAction, 'save_action')
service_type = self.get_current_service_type()
filter_widget = self.get_service_filter_widget(service_type)
save_current_action.setEnabled(
hasattr(filter_widget, 'to_service_definition'))
def _refresh_services(self):
"""
Refreshes the list of available services
"""
# fill the FDSN listWidget with the dictionary keys
self.fdsn_event_list.clear()
self.fdsn_event_list.addItems(
SERVICE_MANAGER.available_services(SERVICE_MANAGER.FDSNEVENT))
self.fdsn_event_list.setCurrentRow(0)
# fill the FDSN listWidget with the dictionary keys
self.fdsn_macro_list.clear()
self.fdsn_macro_list.addItems(
SERVICE_MANAGER.available_services(SERVICE_MANAGER.MACROSEISMIC))
self.fdsn_macro_list.setCurrentRow(0)
# fill the FDSN listWidget with the dictionary keys
self.fdsn_station_list.clear()
self.fdsn_station_list.addItems(
SERVICE_MANAGER.available_services(SERVICE_MANAGER.FDSNSTATION))
self.fdsn_station_list.setCurrentRow(0)
self.refreshOgcWidgets()
def _save_configuration(self):
"""
Triggers saving the current service configuration
"""
service_type = self.get_current_service_type()
name, ok = QInputDialog.getText(
self, self.tr('Save Service Configuration'),
self.tr('Save the current service configuration as'))
if not name or not ok:
return
filter_widget = self.get_service_filter_widget(service_type)
SERVICE_MANAGER.save_service(service_type, name,
filter_widget.to_service_definition())
self.set_current_service(service_type, name)
def _save_settings(self):
"""
Saves all settings currently defined in the dialog
"""
s = QgsSettings()
if self.service_tab_widget.currentIndex(
) != self.service_tab_widget.count() - 1:
s.setValue('/plugins/qquake/last_tab',
self.service_tab_widget.currentIndex())
s.setValue('/plugins/qquake/fdsn_event_last_event_service',
self.fdsn_event_list.currentItem().text())
s.setValue('/plugins/qquake/macro_last_event_service',
self.fdsn_macro_list.currentItem().text())
s.setValue('/plugins/qquake/fdsnevent_last_tab',
self.fdsn_tab_widget.currentIndex())
s.setValue('/plugins/qquake/macro_last_tab',
self.macro_tab_widget.currentIndex())
s.setValue('/plugins/qquake/station_last_tab',
self.fdsnstation_tab_widget.currentIndex())
self.fdsn_event_filter.save_settings('fdsn_event')
self.fdsn_by_id_filter.save_settings('fdsn_event')
self.fdsn_by_url_widget.save_settings('fdsn_event')
self.macro_filter.save_settings('macro')
self.macro_by_id_filter.save_settings('macro')
self.macro_by_url_widget.save_settings('macro')
self.station_filter.save_settings('stations')
self.station_by_id_filter.save_settings('stations')
self.station_by_url_widget.save_settings('stations')
def _restore_settings(self):
"""
Restores dialog settings
"""
s = QgsSettings()
last_tab = s.value('/plugins/qquake/last_tab')
if last_tab is not None:
self.service_tab_widget.setCurrentIndex(int(last_tab))
last_service = s.value('/plugins/qquake/fdsn_event_last_event_service')
if last_service is not None:
try:
self.fdsn_event_list.setCurrentItem(
self.fdsn_event_list.findItems(last_service,
Qt.MatchContains)[0])
except IndexError:
pass
last_service = s.value('/plugins/qquake/macro_last_event_service')
if last_service is not None:
self.fdsn_macro_list.setCurrentItem(
self.fdsn_macro_list.findItems(last_service,
Qt.MatchContains)[0])
self.fdsn_event_filter.restore_settings('fdsn_event')
self.fdsn_by_id_filter.restore_settings('fdsn_event')
self.fdsn_by_url_widget.restore_settings('fdsn_event')
self.macro_filter.restore_settings('macro')
self.macro_by_id_filter.restore_settings('macro')
self.macro_by_url_widget.restore_settings('fdsn_event')
self.station_filter.restore_settings('stations')
self.station_by_id_filter.restore_settings('stations')
self.station_by_url_widget.restore_settings('stations')
self.fdsn_tab_widget.setCurrentIndex(
s.value('/plugins/qquake/fdsnevent_last_tab', 0, int))
self.macro_tab_widget.setCurrentIndex(
s.value('/plugins/qquake/macro_last_tab', 0, int))
self.fdsnstation_tab_widget.setCurrentIndex(
s.value('/plugins/qquake/station_last_tab', 0, int))
def get_current_service_id(self, service_type: str) -> Optional[str]:
"""
Returns the current selected service id
"""
if service_type == SERVICE_MANAGER.FDSNEVENT:
service_id = self.fdsn_event_list.currentItem().text(
) if self.fdsn_event_list.currentItem() else None
elif service_type == SERVICE_MANAGER.MACROSEISMIC:
service_id = self.fdsn_macro_list.currentItem().text(
) if self.fdsn_macro_list.currentItem() else None
elif service_type == SERVICE_MANAGER.FDSNSTATION:
service_id = self.fdsn_station_list.currentItem().text(
) if self.fdsn_station_list.currentItem() else None
elif service_type in (SERVICE_MANAGER.WMS, SERVICE_MANAGER.WFS):
service_id = self.ogc_list.selectionModel().selectedIndexes(
)[0].data() if self.ogc_list.selectionModel().selectedIndexes(
) else None
else:
service_id = None
return service_id
def get_current_service_type(self) -> Optional[str]:
"""
Returns the current service type
"""
if self.service_tab_widget.currentIndex() == 0:
service_type = SERVICE_MANAGER.FDSNEVENT
elif self.service_tab_widget.currentIndex() == 1:
service_type = SERVICE_MANAGER.MACROSEISMIC
elif self.service_tab_widget.currentIndex() == 2:
service_type = SERVICE_MANAGER.FDSNSTATION
elif self.service_tab_widget.currentIndex() == 3:
return self.ogc_combo.currentData()
else:
service_type = None
return service_type
def get_service_filter_widget(
self, # pylint:disable=too-many-branches
service_type: str
) -> Optional[
Union[FilterParameterWidget, FilterByIdWidget, FetchByUrlWidget,
FilterStationByIdWidget, OgcServiceWidget]]:
"""
Returns the service filter widget for a specific service type
"""
widget = None
if service_type == SERVICE_MANAGER.FDSNEVENT:
if self.fdsn_tab_widget.currentIndex() in (0, 3):
widget = self.fdsn_event_filter
elif self.fdsn_tab_widget.currentIndex() == 1:
widget = self.fdsn_by_id_filter
elif self.fdsn_tab_widget.currentIndex() == 2:
widget = self.fdsn_by_url_widget
elif service_type == SERVICE_MANAGER.MACROSEISMIC:
if self.macro_tab_widget.currentIndex() in (0, 3):
widget = self.macro_filter
elif self.macro_tab_widget.currentIndex() == 1:
widget = self.macro_by_id_filter
elif self.macro_tab_widget.currentIndex() == 2:
widget = self.macro_by_url_widget
elif service_type == SERVICE_MANAGER.FDSNSTATION:
if self.fdsnstation_tab_widget.currentIndex() in (0, 3):
widget = self.station_filter
elif self.fdsnstation_tab_widget.currentIndex() == 1:
widget = self.station_by_id_filter
elif self.fdsnstation_tab_widget.currentIndex() == 2:
widget = self.station_by_url_widget
elif service_type in (SERVICE_MANAGER.WMS, SERVICE_MANAGER.WFS):
widget = self.ogc_service_widget
return widget
def get_fetcher(self, service_type: Optional[str] = None):
"""
Returns a quake fetcher corresponding to the current dialog settings
"""
if service_type is None:
service_type = self.get_current_service_type()
service = self.get_current_service_id(service_type)
if not service:
return None
filter_widget = self.get_service_filter_widget(service_type)
service_config = SERVICE_MANAGER.service_details(service_type, service)
if isinstance(filter_widget, FilterParameterWidget):
fetcher = Fetcher(
service_type=service_type,
event_service=service,
event_start_date=filter_widget.start_date(),
event_end_date=filter_widget.end_date(),
event_min_magnitude=filter_widget.min_magnitude(),
event_max_magnitude=filter_widget.max_magnitude(),
limit_extent_rect=filter_widget.extent_rect(),
min_latitude=filter_widget.min_latitude(),
max_latitude=filter_widget.max_latitude(),
min_longitude=filter_widget.min_longitude(),
max_longitude=filter_widget.max_longitude(),
limit_extent_circle=filter_widget.limit_extent_circle(),
circle_latitude=filter_widget.circle_latitude(),
circle_longitude=filter_widget.circle_longitude(),
circle_min_radius=filter_widget.circle_min_radius(),
circle_max_radius=filter_widget.circle_max_radius(),
circle_radius_unit=filter_widget.circle_radius_unit(),
earthquake_number_mdps_greater=filter_widget.
earthquake_number_mdps_greater(),
earthquake_max_intensity_greater=filter_widget.
earthquake_max_intensity_greater(),
output_fields=filter_widget.output_fields,
output_type=filter_widget.output_type(),
convert_negative_depths=filter_widget.convert_negative_depths(
),
depth_unit=filter_widget.depth_unit(),
event_type=filter_widget.event_type(),
updated_after=filter_widget.updated_after())
elif isinstance(filter_widget, FilterByIdWidget):
if not service_config['settings'].get('queryeventid'):
fetcher = None
else:
fetcher = Fetcher(
service_type=service_type,
event_service=service,
event_ids=filter_widget.ids(),
contributor_id=filter_widget.contributor_id(),
output_fields=filter_widget.output_fields,
output_type=filter_widget.output_type(),
convert_negative_depths=filter_widget.
convert_negative_depths(),
depth_unit=filter_widget.depth_unit())
elif isinstance(filter_widget, FetchByUrlWidget):
fetcher = Fetcher(service_type=service_type,
event_service=service,
url=filter_widget.url(),
output_fields=filter_widget.output_fields,
output_type=filter_widget.output_type(),
convert_negative_depths=filter_widget.
convert_negative_depths(),
depth_unit=filter_widget.depth_unit())
elif isinstance(filter_widget, FilterStationByIdWidget):
fetcher = Fetcher(service_type=service_type,
event_service=service,
network_codes=filter_widget.network_codes(),
station_codes=filter_widget.station_codes(),
locations=filter_widget.locations(),
output_fields=filter_widget.output_fields,
output_type=filter_widget.output_type(),
convert_negative_depths=filter_widget.
convert_negative_depths(),
depth_unit=filter_widget.depth_unit())
return fetcher
def _refresh_url(self, service_type: Optional[str] = None):
"""
Updates the service URL
"""
if not service_type:
service_type = self.get_current_service_type()
if service_type is None:
self.button_box.button(QDialogButtonBox.Ok).setEnabled(False)
return
if service_type not in (SERVICE_MANAGER.FDSNEVENT,
SERVICE_MANAGER.MACROSEISMIC,
SERVICE_MANAGER.FDSNSTATION):
self.button_box.button(QDialogButtonBox.Ok).setEnabled(True)
return
fetcher = self.get_fetcher(service_type)
if not fetcher:
self.button_box.button(QDialogButtonBox.Ok).setEnabled(False)
return
self._valid_changed()
if service_type == SERVICE_MANAGER.FDSNEVENT:
self.fdsn_event_url_text_browser.setText(
'<a href="{0}">{0}</a>'.format(fetcher.generate_url()))
elif service_type == SERVICE_MANAGER.MACROSEISMIC:
self.fdsn_macro_url_text_browser.setText(
'<a href="{0}">{0}</a>'.format(fetcher.generate_url()))
elif service_type == SERVICE_MANAGER.FDSNSTATION:
self.fdsn_station_url_text_browser.setText(
'<a href="{0}">{0}</a>'.format(fetcher.generate_url()))
def _valid_changed(self):
"""
Called when dialog entry validation should occur
"""
service_type = self.get_current_service_type()
if service_type not in (SERVICE_MANAGER.FDSNEVENT,
SERVICE_MANAGER.MACROSEISMIC,
SERVICE_MANAGER.FDSNSTATION):
self.button_box.button(QDialogButtonBox.Ok).setEnabled(True)
return
filter_widget = self.get_service_filter_widget(service_type)
self.button_box.button(QDialogButtonBox.Ok).setEnabled(
filter_widget.is_valid())
def _update_service_widgets(
self, # pylint: disable=too-many-locals,too-many-branches
service_type,
service_id,
filter_widget,
filter_by_id_widget,
fetch_by_url_widget,
info_widget,
remove_service_button,
edit_service_button,
rename_service_button,
tab_widget):
"""
Updates all widgets to reflect the current service details
"""
service_config = SERVICE_MANAGER.service_details(
service_type, service_id)
date_start = QDateTime.fromString(service_config['datestart'],
Qt.ISODate)
default_date_start = QDateTime.fromString(
service_config['default']['datestart'],
Qt.ISODate) if service_config['default'].get('datestart') else None
# if the dateend is not set in the config.json set the date to NOW
date_end = QDateTime.fromString(
service_config['dateend'],
Qt.ISODate) if 'dateend' in service_config and service_config[
'dateend'] else None
default_date_end = QDateTime.fromString(
service_config['default']['dateend'],
Qt.ISODate) if service_config['default'].get('dateend') else None
filter_widget.set_date_range_limits(date_start, date_end)
filter_widget.set_current_date_range(default_date_start,
default_date_end)
if service_config['default'].get('boundingboxpredefined'):
filter_widget.set_predefined_bounding_box(
service_config['default'].get('boundingboxpredefined'))
if service_config['default'].get('minimumlatitude'):
filter_widget.set_min_latitude(
service_config['default'].get('minimumlatitude'))
if service_config['default'].get('maximumlatitude'):
filter_widget.set_max_latitude(
service_config['default'].get('maximumlatitude'))
if service_config['default'].get('minimumlongitude'):
filter_widget.set_min_longitude(
service_config['default'].get('minimumlongitude'))
if service_config['default'].get('maximumlongitude'):
filter_widget.set_max_longitude(
service_config['default'].get('maximumlongitude'))
if service_config['default'].get('circlelatitude'):
filter_widget.set_circle_latitude(
service_config['default'].get('circlelatitude'))
if service_config['default'].get('circlelongitude'):
filter_widget.set_circle_longitude(
service_config['default'].get('circlelongitude'))
if service_config['default'].get('minimumcircleradius'):
filter_widget.set_min_circle_radius(
service_config['default'].get('minimumcircleradius'))
if service_config['default'].get('maximumcircleradius'):
filter_widget.set_max_circle_radius(
service_config['default'].get('maximumcircleradius'))
if service_config['default'].get('minimummagnitude'):
filter_widget.set_min_magnitude(
service_config['default'].get('minimummagnitude'))
if service_config['default'].get('maximummagnitude'):
filter_widget.set_max_magnitude(
service_config['default'].get('maximummagnitude'))
if service_config['default'].get('macromaxintensitygreater'):
filter_widget.set_max_intensity_greater(
service_config['default'].get('macromaxintensitygreater'))
if service_config['default'].get('macromdpsgreaterthan'):
filter_widget.set_mdps_greater_than(
service_config['default'].get('macromdpsgreaterthan'))
if service_config['default'].get('eventtype'):
filter_widget.set_event_type(
service_config['default'].get('eventtype'))
updated_after = QDateTime.fromString(
service_config['default']['updatedafter'], Qt.ISODate
) if service_config['default'].get('updatedafter') else None
if updated_after:
filter_widget.set_updated_after(updated_after)
filter_widget.set_extent_limit(
service_config.get('boundingbox', [-180, -90, 180, 90]))
if service_type in [
SERVICE_MANAGER.FDSNEVENT, SERVICE_MANAGER.MACROSEISMIC
]:
tab_widget.widget(1).setEnabled(service_config['settings'].get(
'queryeventid', False))
info_widget.set_service(service_type=service_type,
service_id=service_id)
filter_widget.set_service_id(service_id)
filter_by_id_widget.set_service_id(service_id)
if fetch_by_url_widget is not None:
fetch_by_url_widget.set_service_id(service_id)
remove_service_button.setEnabled(not service_config['read_only'])
edit_service_button.setEnabled(not service_config['read_only'])
rename_service_button.setEnabled(not service_config['read_only'])
def _refresh_fdsnevent_widgets(self):
"""
Refreshing the FDSN-Event UI depending on the WS chosen
"""
if not self.fdsn_event_list.currentItem():
return
service_id = self.fdsn_event_list.currentItem().text()
self._update_service_widgets(
service_type=SERVICE_MANAGER.FDSNEVENT,
service_id=service_id,
filter_widget=self.fdsn_event_filter,
filter_by_id_widget=self.fdsn_by_id_filter,
fetch_by_url_widget=self.fdsn_by_url_widget,
info_widget=self.earthquake_service_info_widget,
remove_service_button=self.button_fdsn_remove_service,
edit_service_button=self.button_fdsn_edit_service,
rename_service_button=self.button_fdsn_rename_service,
tab_widget=self.fdsn_tab_widget)
def refreshFdsnMacroseismicWidgets(self):
"""
Refreshing the FDSN-Macroseismic UI depending on the WS chosen
"""
if not self.fdsn_macro_list.currentItem():
return
service_id = self.fdsn_macro_list.currentItem().text()
self._update_service_widgets(
service_type=SERVICE_MANAGER.MACROSEISMIC,
service_id=service_id,
filter_widget=self.macro_filter,
filter_by_id_widget=self.macro_by_id_filter,
fetch_by_url_widget=self.macro_by_url_widget,
info_widget=self.macro_service_info_widget,
remove_service_button=self.button_macro_remove_service,
edit_service_button=self.button_macro_edit_service,
rename_service_button=self.button_macro_rename_service,
tab_widget=self.macro_tab_widget)
def refreshFdsnStationWidgets(self):
"""
Refreshing the FDSN-Macroseismic UI depending on the WS chosen
"""
if not self.fdsn_station_list.currentItem():
return
service_id = self.fdsn_station_list.currentItem().text()
self._update_service_widgets(
service_type=SERVICE_MANAGER.FDSNSTATION,
service_id=service_id,
filter_by_id_widget=self.station_by_id_filter,
fetch_by_url_widget=self.station_by_url_widget,
filter_widget=self.station_filter,
info_widget=self.station_service_info_widget,
remove_service_button=self.button_station_remove_service,
edit_service_button=self.button_station_edit_service,
rename_service_button=self.button_station_rename_service,
tab_widget=self.fdsnstation_tab_widget)
def refreshOgcWidgets(self):
"""
read the ogc_combo and fill it with the services
"""
self.ogc_list_model.clear()
ogc_selection = self.ogc_combo.currentData()
services = SERVICE_MANAGER.available_services(ogc_selection)
group_items = {}
for service in services:
service_config = SERVICE_MANAGER.service_details(
ogc_selection, service)
group = service_config.get('group')
if not group or group in group_items:
continue
group_item = QStandardItem(group)
group_item.setFlags(Qt.ItemIsEnabled)
self.ogc_list_model.appendRow([group_item])
group_items[group] = group_item
first_item = None
for service in services:
item = QStandardItem(service)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
item.setData(service, role=Qt.UserRole)
if not first_item:
first_item = item
service_config = SERVICE_MANAGER.service_details(
ogc_selection, service)
group = service_config.get('group')
if group:
parent = group_items[group]
parent.appendRow([item])
else:
self.ogc_list_model.appendRow([item])
self.ogc_list.expandAll()
first_item_index = self.ogc_list_model.indexFromItem(first_item)
self.ogc_list.selectionModel().select(
first_item_index, QItemSelectionModel.ClearAndSelect)
service_config = SERVICE_MANAGER.service_details(
ogc_selection, self.get_current_service_id(ogc_selection))
self.button_ogc_edit_service.setEnabled(
not service_config['read_only'])
self.button_ogc_rename_service.setEnabled(
not service_config['read_only'])
self.button_ogc_remove_service.setEnabled(
not service_config['read_only'])
def _ogc_service_changed(self, _, __):
"""
Triggered when the current OGC service changes
"""
if not self.ogc_list.selectionModel().selectedIndexes():
return
current_service = self.ogc_list.selectionModel().selectedIndexes(
)[0].data(Qt.UserRole)
if not current_service:
return
self.ogc_service_widget.set_service(
service_type=self.ogc_combo.currentData(),
service_id=current_service)
self.ogc_service_info_widget.set_service(
service_type=self.ogc_combo.currentData(),
service_id=current_service)
service_config = SERVICE_MANAGER.service_details(
self.ogc_combo.currentData(), current_service)
self.button_ogc_edit_service.setEnabled(
not service_config['read_only'])
self.button_ogc_rename_service.setEnabled(
not service_config['read_only'])
self.button_ogc_remove_service.setEnabled(
not service_config['read_only'])
def _remove_service(self):
"""
Removes the current service
"""
service_type = self.get_current_service_type()
service_id = self.get_current_service_id(service_type)
if QMessageBox.question(
self, self.tr('Remove Service'),
self.tr('Are you sure you want to remove "{}"?'.format(
service_id))) != QMessageBox.Yes:
return
SERVICE_MANAGER.remove_service(service_type, service_id)
def _edit_service(self):
"""
Edits the current service
"""
service_type = self.get_current_service_type()
service_id = self.get_current_service_id(service_type)
config_dialog = ServiceConfigurationDialog(self.iface, service_type,
service_id, self)
if config_dialog.exec_():
self.set_current_service(service_type, service_id)
def _rename_service(self):
"""
Renames the current service
"""
service_type = self.get_current_service_type()
service_id = self.get_current_service_id(service_type)
dlg = QgsNewNameDialog(
service_id,
service_id, [],
existing=SERVICE_MANAGER.available_services(service_type))
dlg.setHintString(self.tr('Rename service configuration to'))
dlg.setWindowTitle(self.tr('Rename Service Configuration'))
dlg.setOverwriteEnabled(False)
dlg.setConflictingNameWarning(
self.tr('A configuration with this name already exists'))
if not dlg.exec_():
return
new_name = dlg.name()
SERVICE_MANAGER.rename_service(service_type, service_id, new_name)
self.set_current_service(service_type, new_name)
def set_current_service(self, service_type: str, service_id: str):
"""
Sets the current service
"""
if service_type == SERVICE_MANAGER.FDSNEVENT:
self.fdsn_event_list.setCurrentItem(
self.fdsn_event_list.findItems(service_id,
Qt.MatchContains)[0])
elif service_type == SERVICE_MANAGER.MACROSEISMIC:
self.fdsn_macro_list.setCurrentItem(
self.fdsn_macro_list.findItems(service_id,
Qt.MatchContains)[0])
elif service_type == SERVICE_MANAGER.FDSNSTATION:
self.fdsn_station_list.setCurrentItem(
self.fdsn_station_list.findItems(service_id,
Qt.MatchContains)[0])
elif service_type in (SERVICE_MANAGER.WMS, SERVICE_MANAGER.WFS):
self.ogc_combo.setCurrentIndex(
self.ogc_combo.findData(service_type))
indexes = self.ogc_list_model.match(
self.ogc_list_model.index(0, 0),
Qt.UserRole,
service_id,
flags=Qt.MatchExactly | Qt.MatchRecursive)
if len(indexes) > 0:
self.ogc_list.selectionModel().select(
indexes[0], QItemSelectionModel.ClearAndSelect)
def _create_configuration(self):
"""
Creates a new service configuration
"""
service_type = self.get_current_service_type()
dlg = QgsNewNameDialog(
'',
'', [],
existing=SERVICE_MANAGER.available_services(service_type))
dlg.setHintString(self.tr('Create a new service configuration named'))
dlg.setWindowTitle(self.tr('New Service Configuration'))
dlg.setOverwriteEnabled(False)
dlg.setConflictingNameWarning(
self.tr('A configuration with this name already exists'))
if not dlg.exec_():
return
name = dlg.name()
config_dialog = ServiceConfigurationDialog(self.iface, service_type,
name, self)
if config_dialog.exec_():
self.set_current_service(service_type, name)
def _export_service(self):
"""
Triggers exporting a service configuration
"""
service_type = self.get_current_service_type()
service_id = self.get_current_service_id(service_type)
file, _ = QFileDialog.getSaveFileName(
self, self.tr('Export Service'),
QDir.homePath() + '/{}.json'.format(service_id),
'JSON Files (*.json)')
if not file:
return
file = QgsFileUtils.ensureFileNameHasExtension(file, ['json'])
if SERVICE_MANAGER.export_service(service_type, service_id, file):
self.message_bar.pushMessage(self.tr("Service exported"),
Qgis.Success, 5)
else:
self.message_bar.pushMessage(
self.tr("An error occurred while exporting service"),
Qgis.Critical, 5)
def _import_configuration(self):
"""
Triggers importing a configuration
"""
file, _ = QFileDialog.getOpenFileName(self, self.tr('Import Service'),
QDir.homePath(),
'JSON Files (*.json)')
if not file:
return
res, err = SERVICE_MANAGER.import_service(file)
if res:
self.message_bar.pushMessage(self.tr("Service imported"),
Qgis.Success, 5)
else:
self.message_bar.pushMessage(err, Qgis.Critical, 5)
def _getEventList(self):
"""
read the event URL and convert the response in a list
"""
if self.get_current_service_type() in (SERVICE_MANAGER.WMS,
SERVICE_MANAGER.WFS):
self.ogc_service_widget.add_selected_layers()
return
if self.fetcher:
# TODO - cancel current request
return
self.fetcher = self.get_fetcher()
def on_started():
self.progressBar.setValue(0)
self.progressBar.setRange(0, 0)
def on_progress(progress: float):
self.progressBar.setRange(0, 100)
self.progressBar.setValue(progress)
self.fetcher.started.connect(on_started)
self.fetcher.progress.connect(on_progress)
self.fetcher.finished.connect(self._fetcher_finished)
self.fetcher.message.connect(self._fetcher_message)
self.button_box.button(QDialogButtonBox.Ok).setText(
self.tr('Fetching'))
self.button_box.button(QDialogButtonBox.Ok).setEnabled(False)
self.fetcher.fetch_data()
def _fetcher_message(self, message, level):
"""
Handles message feedback from a fetcher
"""
self.message_bar.clearWidgets()
self.message_bar.pushMessage(message, level, 0)
def _fetcher_finished(self, res): # pylint: disable=too-many-branches
"""
Triggered when a fetcher is finished
"""
self.progressBar.setRange(0, 100)
self.progressBar.reset()
self.button_box.button(QDialogButtonBox.Ok).setText(
self.tr('Fetch Data'))
self.button_box.button(QDialogButtonBox.Ok).setEnabled(True)
if not res:
self.fetcher.deleteLater()
self.fetcher = None
return
found_results = False
layers = []
if self.fetcher.service_type in (SERVICE_MANAGER.FDSNEVENT,
SERVICE_MANAGER.MACROSEISMIC):
layer = self.fetcher.create_event_layer()
if layer:
layers.append(layer)
if self.fetcher.service_type == SERVICE_MANAGER.MACROSEISMIC:
layer = self.fetcher.create_mdp_layer()
if layer:
layers.append(layer)
if layers:
events_count = layers[0].featureCount()
found_results = bool(events_count)
service_limit = self.fetcher.service_config['settings'].get(
'querylimitmaxentries', None)
self.message_bar.clearWidgets()
if service_limit is not None and events_count >= service_limit:
self.message_bar.pushMessage(
self.tr("Query exceeded the service's result limit"),
Qgis.Critical, 0)
elif events_count > 500:
self.message_bar.pushMessage(
self.tr(
"Query returned a large number of results ({})".
format(events_count)), Qgis.Warning, 0)
elif events_count == 0:
self.message_bar.pushMessage(
self.
tr("Query returned no results - possibly parameters are invalid for this service"
), Qgis.Critical, 0)
else:
self.message_bar.pushMessage(
self.tr("Query returned {} records").format(
events_count), Qgis.Success, 0)
elif self.fetcher.service_type == SERVICE_MANAGER.FDSNSTATION:
layers.append(self.fetcher.create_stations_layer())
stations_count = layers[0].featureCount()
found_results = bool(stations_count)
if stations_count == 0:
self.message_bar.pushMessage(
self.
tr("Query returned no results - possibly parameters are invalid for this service"
), Qgis.Critical, 0)
else:
self.message_bar.pushMessage(
self.tr("Query returned {} stations").format(
stations_count), Qgis.Info, 0)
else:
assert False
self.fetcher.deleteLater()
self.fetcher = None
if found_results:
QgsProject.instance().addMapLayers(layers)
class SPAQLunicornDialog(QtWidgets.QDialog, FORM_CLASS):
## The triple store configuration file
triplestoreconf = None
## Prefix map
prefixes = None
enrichtab = None
interlinktab = None
conceptList = None
completerClassList = None
columnvars = {}
def __init__(self,
triplestoreconf={},
prefixes=[],
addVocabConf={},
autocomplete={},
prefixstore={
"normal": {},
"reversed": {}
},
savedQueriesJSON={},
maindlg=None,
parent=None):
"""Constructor."""
super(SPAQLunicornDialog, self).__init__(parent)
self.setupUi(self)
self.prefixes = prefixes
self.maindlg = maindlg
self.savedQueriesJSON = savedQueriesJSON
self.enrichtab = EnrichmentTab(self)
self.interlinktab = InterlinkingTab(self)
self.addVocabConf = addVocabConf
self.autocomplete = autocomplete
self.prefixstore = prefixstore
self.triplestoreconf = triplestoreconf
self.searchTripleStoreDialog = TripleStoreDialog(
self.triplestoreconf, self.prefixes, self.prefixstore,
self.comboBox)
self.geoClassList.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.geoClassList.setAlternatingRowColors(True)
self.geoClassList.setViewMode(QListView.ListMode)
self.geoClassList.setContextMenuPolicy(Qt.CustomContextMenu)
self.geoClassList.customContextMenuRequested.connect(self.onContext)
self.geoClassListModel = QStandardItemModel()
self.proxyModel = QSortFilterProxyModel(self)
self.proxyModel.sort(0)
self.proxyModel.setSourceModel(self.geoClassListModel)
self.geoClassList.setModel(self.proxyModel)
self.geoClassListModel.clear()
self.queryLimit.setValidator(QRegExpValidator(QRegExp("[0-9]*")))
self.filterConcepts.textChanged.connect(self.setFilterFromText)
self.inp_sparql2 = ToolTipPlainText(self.tab, self.triplestoreconf,
self.comboBox, self.columnvars,
self.prefixes, self.autocomplete)
self.inp_sparql2.move(10, 130)
self.inp_sparql2.setMinimumSize(780, 401)
self.inp_sparql2.document().defaultFont().setPointSize(16)
self.inp_sparql2.setPlainText(
"SELECT ?item ?lat ?lon WHERE {\n ?item ?b ?c .\n ?item <http://www.wikidata.org/prop:P123> ?def .\n}"
)
self.inp_sparql2.columnvars = {}
self.inp_sparql2.textChanged.connect(self.validateSPARQL)
self.sparqlhighlight = SPARQLHighlighter(self.inp_sparql2)
self.areaconcepts.hide()
self.areas.hide()
self.label_8.hide()
self.label_9.hide()
self.savedQueries.hide()
self.loadQuery.hide()
self.saveQueryButton.hide()
self.saveQueryName.hide()
self.savedQueryLabel.hide()
self.saveQueryName_2.hide()
self.enrichTableResult.hide()
self.queryTemplates.currentIndexChanged.connect(self.viewselectaction)
self.bboxButton.clicked.connect(self.getPointFromCanvas)
self.interlinkTable.cellClicked.connect(
self.createInterlinkSearchDialog)
self.enrichTable.cellClicked.connect(self.createEnrichSearchDialog)
self.chooseLayerInterlink.clear()
self.searchClass.clicked.connect(self.createInterlinkSearchDialog)
urlregex = QRegExp(
"http[s]?://(?:[a-zA-Z#]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+"
)
urlvalidator = QRegExpValidator(urlregex, self)
self.interlinkNameSpace.setValidator(urlvalidator)
self.interlinkNameSpace.textChanged.connect(self.check_state3)
self.interlinkNameSpace.textChanged.emit(
self.interlinkNameSpace.text())
self.addEnrichedLayerButton.clicked.connect(
self.enrichtab.addEnrichedLayer)
self.startEnrichment.clicked.connect(self.enrichtab.enrichLayerProcess)
self.exportInterlink.clicked.connect(
self.enrichtab.exportEnrichedLayer)
self.loadQuery.clicked.connect(self.loadQueryFunc)
self.saveQueryButton.clicked.connect(self.saveQueryFunc)
self.exportMappingButton.clicked.connect(
self.interlinktab.exportMapping)
self.importMappingButton.clicked.connect(self.interlinktab.loadMapping)
self.loadLayerInterlink.clicked.connect(self.loadLayerForInterlink)
self.loadLayerEnrich.clicked.connect(self.loadLayerForEnrichment)
self.addEnrichedLayerRowButton.clicked.connect(self.addEnrichRow)
self.geoClassList.selectionModel().selectionChanged.connect(
self.viewselectaction)
self.loadFileButton.clicked.connect(self.buildLoadGraphDialog)
self.refreshLayersInterlink.clicked.connect(self.loadUnicornLayers)
self.btn_loadunicornlayers.clicked.connect(self.loadUnicornLayers)
self.whattoenrich.clicked.connect(self.createWhatToEnrich)
self.quickAddTripleStore.clicked.connect(self.buildQuickAddTripleStore)
self.loadTripleStoreButton.clicked.connect(
self.buildCustomTripleStoreDialog)
self.loadUnicornLayers()
def loadQueryFunc(self):
if self.triplestoreconf[self.comboBox.currentIndex(
)]["endpoint"] in self.savedQueriesJSON:
self.inp_sparql2.setPlainText(self.savedQueriesJSON[
self.triplestoreconf[self.comboBox.currentIndex()]
["endpoint"]][self.savedQueries.currentIndex()]["query"])
def saveQueryFunc(self):
queryName = self.saveQueryName.text()
if queryName != None and queryName != "":
__location__ = os.path.realpath(
os.path.join(os.getcwd(), os.path.dirname(__file__)))
self.savedQueriesJSON[self.triplestoreconf[
self.comboBox.currentIndex()]["endpoint"]].append({
"label":
queryName,
"query":
self.inp_sparql2.toPlainText()
})
self.savedQueries.addItem(queryName)
f = open(os.path.join(__location__, 'savedqueries.json'), "w")
f.write(json.dumps(self.savedQueriesJSON))
f.close()
def onContext(self):
menu = QMenu("Menu", self.geoClassList)
action = QAction("Open in Webbrowser")
menu.addAction(action)
action.triggered.connect(self.openURL)
def openURL(self):
curindex = self.proxyModel.mapToSource(
self.geoClassList.selectionModel().currentIndex())
concept = self.geoClassListModel.itemFromIndex(curindex).data(1)
url = QUrl(concept)
QDesktopServices.openUrl(url)
def setFilterFromText(self):
self.proxyModel.setFilterRegExp(self.filterConcepts.text())
##
# @brief Creates a What To Enrich dialog with parameters given.
#
# @param self The object pointer
def buildLoadGraphDialog(self):
self.searchTripleStoreDialog = LoadGraphDialog(self.triplestoreconf,
self.maindlg, self)
self.searchTripleStoreDialog.setWindowTitle("Load Graph")
self.searchTripleStoreDialog.exec_()
##
# @brief Creates a What To Enrich dialog with parameters given.
#
# @param self The object pointer
def buildQuickAddTripleStore(self):
self.searchTripleStoreDialog = TripleStoreQuickAddDialog(
self.triplestoreconf, self.prefixes, self.prefixstore,
self.comboBox)
self.searchTripleStoreDialog.setMinimumSize(580, 186)
self.searchTripleStoreDialog.setWindowTitle(
"Configure Own Triple Store")
self.searchTripleStoreDialog.exec_()
##
# @brief Creates a What To Enrich dialog with parameters given.
#
# @param self The object pointer
def buildCustomTripleStoreDialog(self):
self.searchTripleStoreDialog = TripleStoreDialog(
self.triplestoreconf, self.prefixes, self.prefixstore,
self.comboBox)
self.searchTripleStoreDialog.setMinimumSize(700, 500)
self.searchTripleStoreDialog.setWindowTitle(
"Configure Own Triple Store")
self.searchTripleStoreDialog.exec_()
##
# @brief Creates a What To Enrich dialog with parameters given.
#
# @param self The object pointer
def createWhatToEnrich(self):
if self.enrichTable.rowCount() == 0:
return
layers = QgsProject.instance().layerTreeRoot().children()
selectedLayerIndex = self.chooseLayerEnrich.currentIndex()
layer = layers[selectedLayerIndex].layer()
self.searchTripleStoreDialog = EnrichmentDialog(
self.triplestoreconf, self.prefixes, self.enrichTable, layer, None,
None)
self.searchTripleStoreDialog.setMinimumSize(700, 500)
self.searchTripleStoreDialog.setWindowTitle("Enrichment Search")
self.searchTripleStoreDialog.exec_()
def check_state3(self):
self.searchTripleStoreDialog.check_state(self.interlinkNameSpace)
def createEnrichSearchDialog(self, row=-1, column=-1):
if column == 1:
self.buildSearchDialog(row, column, False, self.enrichTable, False,
False, None, self.addVocabConf)
if column == 6:
self.buildSearchDialog(row, column, False, self.enrichTable, False,
False, None, self.addVocabConf)
def createEnrichSearchDialogProp(self, row=-1, column=-1):
self.buildSearchDialog(row, column, False, self.findIDPropertyEdit,
True, False, None, self.addVocabConf)
##
# @brief Creates a search dialog with parameters for interlinking.
#
# @param self The object pointer
# @param row The row of the table for which to map the search result
# @param column The column of the table for which to map the search result
def createInterlinkSearchDialog(self, row=-1, column=-1):
if column > 3 and column < 7:
self.buildSearchDialog(row, column, True, self.interlinkTable,
True, False, None, self.addVocabConf)
elif column >= 7:
layers = QgsProject.instance().layerTreeRoot().children()
selectedLayerIndex = self.chooseLayerInterlink.currentIndex()
layer = layers[selectedLayerIndex].layer()
self.buildValueMappingDialog(row, column, True,
self.interlinkTable, layer)
elif column == -1:
self.buildSearchDialog(row, column, -1,
self.interlinkOwlClassInput, False, False,
None, self.addVocabConf)
##
# @brief Shows the configuration table after creating an enrichment result.
#
# @param self The object pointer
#
def showConfigTable(self):
self.enrichTableResult.hide()
self.enrichTable.show()
self.startEnrichment.setText("Start Enrichment")
self.startEnrichment.clicked.disconnect()
self.startEnrichment.clicked.connect(self.enrichtab.enrichLayerProcess)
##
# @brief Executes a GUI event when a new SPARQL endpoint is selected.
# Usually loads the list of concepts related to the SPARQL endpoint
# @param send The sender of the request
#
def viewselectaction(self):
endpointIndex = self.comboBox.currentIndex()
if endpointIndex == 0:
self.justloadingfromfile = False
return
concept = ""
curindex = self.proxyModel.mapToSource(
self.geoClassList.selectionModel().currentIndex())
if self.geoClassList.selectionModel().currentIndex(
) != None and self.geoClassListModel.itemFromIndex(
curindex) != None and re.match(
r'.*Q[0-9]+.*',
self.geoClassListModel.itemFromIndex(curindex).text()
) and not self.geoClassListModel.itemFromIndex(
curindex).text().startswith("http"):
self.inp_label.setText(
self.geoClassListModel.itemFromIndex(curindex).text().split(
"(")[0].lower().replace(" ", "_"))
concept = "Q" + self.geoClassListModel.itemFromIndex(
curindex).text().split("Q")[1].replace(")", "")
elif self.geoClassListModel.itemFromIndex(curindex) != None:
concept = self.geoClassListModel.itemFromIndex(curindex).data(1)
if "querytemplate" in self.triplestoreconf[endpointIndex]:
if "wd:Q%%concept%% ." in self.triplestoreconf[endpointIndex][
"querytemplate"][
self.queryTemplates.currentIndex()]["query"]:
querytext = ""
if concept != None and concept.startswith("http"):
querytext = self.triplestoreconf[endpointIndex][
"querytemplate"][self.queryTemplates.currentIndex(
)]["query"].replace(
"wd:Q%%concept%% .",
"wd:" + concept[concept.rfind('/') + 1:] + " .")
elif concept != None:
querytext = self.triplestoreconf[endpointIndex][
"querytemplate"][self.queryTemplates.currentIndex(
)]["query"].replace("wd:Q%%concept%% .",
"wd:" + concept + " .")
else:
querytext = self.triplestoreconf[endpointIndex][
"querytemplate"][
self.queryTemplates.currentIndex()]["query"].replace(
"%%concept%%", concept)
if self.queryLimit.text().isnumeric(
) and querytext.rfind("LIMIT") != -1:
querytext = querytext[0:querytext.rfind(
"LIMIT")] + "LIMIT " + self.queryLimit.text()
elif self.queryLimit.text().isnumeric() and querytext.rfind(
"LIMIT") == -1:
querytext = querytext + " LIMIT " + self.queryLimit.text()
self.inp_sparql2.setPlainText(querytext)
self.inp_sparql2.columnvars = {}
if self.geoClassList.selectionModel().currentIndex(
) != None and self.geoClassListModel.itemFromIndex(
curindex
) != None and "#" in self.geoClassListModel.itemFromIndex(
curindex).text():
self.inp_label.setText(
self.geoClassListModel.itemFromIndex(curindex).text()
[self.geoClassListModel.itemFromIndex(curindex).text().
rfind('#') + 1:].lower().replace(" ", "_"))
elif self.geoClassList.selectionModel().currentIndex(
) != None and self.geoClassListModel.itemFromIndex(curindex) != None:
self.inp_label.setText(
self.geoClassListModel.itemFromIndex(curindex).text()
[self.geoClassListModel.itemFromIndex(curindex).text().
rfind('/') + 1:].lower().replace(" ", "_"))
def itemModelToMap(self, model):
resdict = {}
for row in range(model.rowCount()):
index = model.index(row, 0, self)
resdict[model.itemFromIndex(index).text()] = model.itemFromIndex(
index).data(1)
return resdict
##
# @brief Deletes a row from the table in the enrichment dialog.
#
# @param send The sender of the request
#
def deleteEnrichRow(send):
w = send.sender().parent()
row = self.enrichTable.indexAt(w.pos()).row()
self.enrichTable.removeRow(row)
self.enrichTable.setCurrentCell(0, 0)
##
# @brief Adds a new row to the table in the enrichment dialog.
#
# @param self The object pointer
#
def addEnrichRow(self):
layers = QgsProject.instance().layerTreeRoot().children()
selectedLayerIndex = self.chooseLayerEnrich.currentIndex()
layer = layers[selectedLayerIndex].layer()
self.enrichTableResult.hide()
fieldnames = [field.name() for field in layer.fields()]
item = QTableWidgetItem("new_column")
#item.setFlags(QtCore.Qt.ItemIsEnabled)
row = self.enrichTable.rowCount()
self.enrichTable.insertRow(row)
self.enrichTable.setItem(row, 0, item)
cbox = QComboBox()
cbox.addItem("Get Remote")
cbox.addItem("No Enrichment")
cbox.addItem("Exclude")
self.enrichTable.setCellWidget(row, 3, cbox)
cbox = QComboBox()
cbox.addItem("Enrich Value")
cbox.addItem("Enrich URI")
cbox.addItem("Enrich Both")
self.enrichTable.setCellWidget(row, 4, cbox)
cbox = QComboBox()
for fieldd in fieldnames:
cbox.addItem(fieldd)
self.enrichTable.setCellWidget(row, 5, cbox)
itemm = QTableWidgetItem("http://www.w3.org/2000/01/rdf-schema#label")
self.enrichTable.setItem(row, 6, itemm)
itemm = QTableWidgetItem("")
self.enrichTable.setItem(row, 7, itemm)
itemm = QTableWidgetItem("")
self.enrichTable.setItem(row, 8, itemm)
## Validates the SPARQL query in the input field and outputs errors in a label.
# @param self The object pointer.
def validateSPARQL(self):
if self.prefixes != None and self.comboBox != None and self.comboBox.currentIndex(
) != None and self.prefixes[self.comboBox.currentIndex(
)] != None and self.inp_sparql2.toPlainText(
) != None and self.inp_sparql2.toPlainText() != "":
try:
if self.prefixes[self.comboBox.currentIndex()] != "":
prepareQuery(
"".join(self.prefixes[self.comboBox.currentIndex()]) +
"\n" + self.inp_sparql2.toPlainText())
self.errorLabel.setText("Valid Query")
self.errorline = -1
self.sparqlhighlight.errorhighlightline = self.errorline
self.sparqlhighlight.currentline = 0
self.inp_sparql2.errorline = None
except Exception as e:
match = re.search(r'line:([0-9]+),', str(e))
match2 = re.search(r'col:([0-9]+),', str(e))
start = int(match.group(1)) - len(self.triplestoreconf[
self.comboBox.currentIndex()]["prefixes"]) - 1
self.errorLabel.setText(
re.sub("line:([0-9]+),", "line: " + str(start) + ",",
str(e)))
self.inp_sparql2.errorline = start - 1
if "line" in str(e):
ex = str(e)
start = ex.find('line:') + 5
end = ex.find(',', start)
start2 = ex.find('col:') + 4
end2 = ex.find(')', start2)
self.errorline = ex[start:end]
self.sparqlhighlight.errorhighlightcol = ex[start2:end2]
self.sparqlhighlight.errorhighlightline = self.errorline
self.sparqlhighlight.currentline = 0
##
# @brief Builds the search dialog to search for a concept or class.
# @param self The object pointer
# @param row the row to insert the result
# @param column the column to insert the result
# @param interlinkOrEnrich indicates if the dialog is meant for interlinking or enrichment
# @param table the GUI element to display the result
def buildSearchDialog(self,
row,
column,
interlinkOrEnrich,
table,
propOrClass,
bothOptions=False,
currentprefixes=None,
addVocabConf=None):
self.currentcol = column
self.currentrow = row
self.interlinkdialog = SearchDialog(column, row, self.triplestoreconf,
self.prefixes, interlinkOrEnrich,
table, propOrClass, bothOptions,
currentprefixes, addVocabConf)
self.interlinkdialog.setMinimumSize(650, 400)
self.interlinkdialog.setWindowTitle("Search Interlink Concept")
self.interlinkdialog.exec_()
##
# @brief Builds a boundingbox dialog allows to pick a bounding box for a SPARQL query.
#
# @param self The object pointer
def getPointFromCanvas(self):
self.d = BBOXDialog(self.inp_sparql2, self.triplestoreconf,
self.comboBox.currentIndex())
self.d.setWindowTitle("Choose BoundingBox")
self.d.exec_()
##
# @brief Builds a value mapping dialog window for ther interlinking dialog.
#
# @param self The object pointer
# @param row The row of the table for which to map the value
# @param column The column of the table for which to map the value
# @param table The table in which to save the value mapping result
# @param layer The layer which is concerned by the enrichment oder interlinking
def buildValueMappingDialog(self, row, column, interlinkOrEnrich, table,
layer):
self.currentcol = column
self.currentrow = row
valuemap = None
if table.item(row, column) != None and table.item(row,
column).text() != "":
valuemap = table.item(row, column).data(1)
self.interlinkdialog = ValueMappingDialog(column, row,
self.triplestoreconf,
interlinkOrEnrich, table,
table.item(row, 3).text(),
layer, valuemap)
self.interlinkdialog.setMinimumSize(650, 400)
self.interlinkdialog.setWindowTitle("Get Value Mappings for column " +
table.item(row, 3).text())
self.interlinkdialog.exec_()
##
# @brief Loads a QGIS layer for interlinking into the interlinking dialog.
#
# @param self The object pointer
def loadLayerForInterlink(self):
layers = QgsProject.instance().layerTreeRoot().children()
selectedLayerIndex = self.chooseLayerInterlink.currentIndex()
if len(layers) == 0:
return
layer = layers[selectedLayerIndex].layer()
fieldnames = [field.name() for field in layer.fields()]
while self.interlinkTable.rowCount() > 0:
self.interlinkTable.removeRow(0)
row = 0
self.interlinkTable.setHorizontalHeaderLabels([
"Export?", "IDColumn?", "GeoColumn?", "Column", "ColumnProperty",
"PropertyType", "ColumnConcept", "ValueConcepts"
])
self.interlinkTable.setColumnCount(8)
for field in fieldnames:
item = QTableWidgetItem(field)
item.setFlags(QtCore.Qt.ItemIsEnabled)
item2 = QTableWidgetItem()
item2.setCheckState(True)
item3 = QTableWidgetItem()
item3.setCheckState(False)
item4 = QTableWidgetItem()
item4.setCheckState(False)
self.interlinkTable.insertRow(row)
self.interlinkTable.setItem(row, 3, item)
self.interlinkTable.setItem(row, 0, item2)
self.interlinkTable.setItem(row, 1, item3)
self.interlinkTable.setItem(row, 2, item4)
cbox = QComboBox()
cbox.addItem("Automatic")
cbox.addItem("AnnotationProperty")
cbox.addItem("DataProperty")
cbox.addItem("ObjectProperty")
cbox.addItem("SubClass")
self.interlinkTable.setCellWidget(row, 5, cbox)
currentRowCount = self.interlinkTable.rowCount()
row += 1
##
# @brief Loads a QGIS layer for enrichment into the enrichment dialog.
#
# @param self The object pointer
def loadLayerForEnrichment(self):
layers = QgsProject.instance().layerTreeRoot().children()
selectedLayerIndex = self.chooseLayerEnrich.currentIndex()
if len(layers) == 0:
return
layer = layers[selectedLayerIndex].layer()
self.enrichTableResult.hide()
while self.enrichTableResult.rowCount() > 0:
self.enrichTableResult.removeRow(0)
self.enrichTable.show()
self.addEnrichedLayerRowButton.setEnabled(True)
fieldnames = [field.name() for field in layer.fields()]
while self.enrichTable.rowCount() > 0:
self.enrichTable.removeRow(0)
row = 0
self.enrichTable.setColumnCount(9)
self.enrichTable.setHorizontalHeaderLabels([
"Column", "EnrichmentConcept", "TripleStore", "Strategy",
"content", "ID Column", "ID Property", "ID Domain", "Language"
])
for field in fieldnames:
item = QTableWidgetItem(field)
item.setFlags(QtCore.Qt.ItemIsEnabled)
currentRowCount = self.enrichTable.rowCount()
self.enrichTable.insertRow(row)
self.enrichTable.setItem(row, 0, item)
cbox = QComboBox()
cbox.addItem("No Enrichment")
cbox.addItem("Keep Local")
cbox.addItem("Keep Remote")
cbox.addItem("Replace Local")
cbox.addItem("Merge")
cbox.addItem("Ask User")
cbox.addItem("Exclude")
self.enrichTable.setCellWidget(row, 3, cbox)
cbox = QComboBox()
cbox.addItem("Enrich Value")
cbox.addItem("Enrich URI")
cbox.addItem("Enrich Both")
self.enrichTable.setCellWidget(row, 4, cbox)
cbox = QComboBox()
for fieldd in fieldnames:
cbox.addItem(fieldd)
self.enrichTable.setCellWidget(row, 5, cbox)
itemm = QTableWidgetItem(
"http://www.w3.org/2000/01/rdf-schema#label")
self.enrichTable.setItem(row, 6, itemm)
itemm = QTableWidgetItem("")
self.enrichTable.setItem(row, 7, itemm)
itemm = QTableWidgetItem("")
self.enrichTable.setItem(row, 8, itemm)
celllayout = QHBoxLayout()
upbutton = QPushButton("Up")
removebutton = QPushButton("Remove", self)
removebutton.clicked.connect(self.deleteEnrichRow)
downbutton = QPushButton("Down")
celllayout.addWidget(upbutton)
celllayout.addWidget(downbutton)
celllayout.addWidget(removebutton)
w = QWidget()
w.setLayout(celllayout)
optitem = QTableWidgetItem()
#self.enrichTable.setCellWidget(row,4,w)
#self.enrichTable.setItem(row,3,cbox)
row += 1
self.originalRowCount = row
## Fetch the currently loaded layers.
# @param self The object pointer.
def loadUnicornLayers(self):
layers = QgsProject.instance().layerTreeRoot().children()
# Populate the comboBox with names of all the loaded unicorn layers
self.loadedLayers.clear()
self.chooseLayerInterlink.clear()
self.chooseLayerEnrich.clear()
for layer in layers:
ucl = layer.name()
#if type(layer) == QgsMapLayer.VectorLayer:
self.loadedLayers.addItem(layer.name())
self.chooseLayerInterlink.addItem(layer.name())
self.chooseLayerEnrich.addItem(layer.name())
class DlgSqlWindow(QWidget, Ui_Dialog):
nameChanged = pyqtSignal(str)
QUERY_HISTORY_LIMIT = 20
def __init__(self, iface, db, parent=None):
QWidget.__init__(self, parent)
self.mainWindow = parent
self.iface = iface
self.db = db
self.dbType = db.connection().typeNameString()
self.connectionName = db.connection().connectionName()
self.filter = ""
self.modelAsync = None
self.allowMultiColumnPk = isinstance(db, PGDatabase) # at the moment only PostgreSQL allows a primary key to span multiple columns, SpatiaLite doesn't
self.aliasSubQuery = isinstance(db, PGDatabase) # only PostgreSQL requires subqueries to be aliases
self.setupUi(self)
self.setWindowTitle(
self.tr(u"{0} - {1} [{2}]").format(self.windowTitle(), self.connectionName, self.dbType))
self.defaultLayerName = self.tr('QueryLayer')
if self.allowMultiColumnPk:
self.uniqueColumnCheck.setText(self.tr("Column(s) with unique values"))
else:
self.uniqueColumnCheck.setText(self.tr("Column with unique values"))
self.editSql.setFocus()
self.editSql.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.editSql.setMarginVisible(True)
self.initCompleter()
settings = QgsSettings()
self.history = settings.value('DB_Manager/queryHistory/' + self.dbType, {self.connectionName: []})
if self.connectionName not in self.history:
self.history[self.connectionName] = []
self.queryHistoryWidget.setVisible(False)
self.queryHistoryTableWidget.verticalHeader().hide()
self.queryHistoryTableWidget.doubleClicked.connect(self.insertQueryInEditor)
self.populateQueryHistory()
self.btnQueryHistory.toggled.connect(self.showHideQueryHistory)
self.btnCancel.setEnabled(False)
self.btnCancel.clicked.connect(self.executeSqlCanceled)
self.btnCancel.setShortcut(QKeySequence.Cancel)
self.progressBar.setEnabled(False)
self.progressBar.setRange(0, 100)
self.progressBar.setValue(0)
self.progressBar.setFormat("")
self.progressBar.setAlignment(Qt.AlignCenter)
# allow copying results
copyAction = QAction("copy", self)
self.viewResult.addAction(copyAction)
copyAction.setShortcuts(QKeySequence.Copy)
copyAction.triggered.connect(self.copySelectedResults)
self.btnExecute.clicked.connect(self.executeSql)
self.btnSetFilter.clicked.connect(self.setFilter)
self.btnClear.clicked.connect(self.clearSql)
self.presetStore.clicked.connect(self.storePreset)
self.presetSaveAsFile.clicked.connect(self.saveAsFilePreset)
self.presetLoadFile.clicked.connect(self.loadFilePreset)
self.presetDelete.clicked.connect(self.deletePreset)
self.presetCombo.activated[str].connect(self.loadPreset)
self.presetCombo.activated[str].connect(self.presetName.setText)
self.updatePresetsCombobox()
self.geomCombo.setEditable(True)
self.geomCombo.lineEdit().setReadOnly(True)
self.uniqueCombo.setEditable(True)
self.uniqueCombo.lineEdit().setReadOnly(True)
self.uniqueModel = QStandardItemModel(self.uniqueCombo)
self.uniqueCombo.setModel(self.uniqueModel)
if self.allowMultiColumnPk:
self.uniqueCombo.setItemDelegate(QStyledItemDelegate())
self.uniqueModel.itemChanged.connect(self.uniqueChanged) # react to the (un)checking of an item
self.uniqueCombo.lineEdit().textChanged.connect(self.uniqueTextChanged) # there are other events that change the displayed text and some of them can not be caught directly
# hide the load query as layer if feature is not supported
self._loadAsLayerAvailable = self.db.connector.hasCustomQuerySupport()
self.loadAsLayerGroup.setVisible(self._loadAsLayerAvailable)
if self._loadAsLayerAvailable:
self.layerTypeWidget.hide() # show if load as raster is supported
self.loadLayerBtn.clicked.connect(self.loadSqlLayer)
self.getColumnsBtn.clicked.connect(self.fillColumnCombos)
self.loadAsLayerGroup.toggled.connect(self.loadAsLayerToggled)
self.loadAsLayerToggled(False)
self._createViewAvailable = self.db.connector.hasCreateSpatialViewSupport()
self.btnCreateView.setVisible(self._createViewAvailable)
if self._createViewAvailable:
self.btnCreateView.clicked.connect(self.createView)
self.queryBuilderFirst = True
self.queryBuilderBtn.setIcon(QIcon(":/db_manager/icons/sql.gif"))
self.queryBuilderBtn.clicked.connect(self.displayQueryBuilder)
self.presetName.textChanged.connect(self.nameChanged)
def insertQueryInEditor(self, item):
sql = item.data(Qt.DisplayRole)
self.editSql.insertText(sql)
def showHideQueryHistory(self, visible):
self.queryHistoryWidget.setVisible(visible)
def populateQueryHistory(self):
self.queryHistoryTableWidget.clearContents()
self.queryHistoryTableWidget.setRowCount(0)
dictlist = self.history[self.connectionName]
if not dictlist:
return
for i in range(len(dictlist)):
self.queryHistoryTableWidget.insertRow(0)
queryItem = QTableWidgetItem(dictlist[i]['query'])
rowsItem = QTableWidgetItem(str(dictlist[i]['rows']))
durationItem = QTableWidgetItem(str(dictlist[i]['secs']))
self.queryHistoryTableWidget.setItem(0, 0, queryItem)
self.queryHistoryTableWidget.setItem(0, 1, rowsItem)
self.queryHistoryTableWidget.setItem(0, 2, durationItem)
self.queryHistoryTableWidget.resizeColumnsToContents()
self.queryHistoryTableWidget.resizeRowsToContents()
def writeQueryHistory(self, sql, affectedRows, secs):
if len(self.history[self.connectionName]) >= self.QUERY_HISTORY_LIMIT:
self.history[self.connectionName].pop(0)
settings = QgsSettings()
self.history[self.connectionName].append({'query': sql,
'rows': affectedRows,
'secs': secs})
settings.setValue('DB_Manager/queryHistory/' + self.dbType, self.history)
self.populateQueryHistory()
def getQueryHash(self, name):
return 'q%s' % md5(name.encode('utf8')).hexdigest()
def updatePresetsCombobox(self):
self.presetCombo.clear()
names = []
entries = QgsProject.instance().subkeyList('DBManager', 'savedQueries')
for entry in entries:
name = QgsProject.instance().readEntry('DBManager', 'savedQueries/' + entry + '/name')[0]
names.append(name)
for name in sorted(names):
self.presetCombo.addItem(name)
self.presetCombo.setCurrentIndex(-1)
def storePreset(self):
query = self._getSqlQuery()
if query == "":
return
name = str(self.presetName.text())
QgsProject.instance().writeEntry('DBManager', 'savedQueries/' + self.getQueryHash(name) + '/name', name)
QgsProject.instance().writeEntry('DBManager', 'savedQueries/' + self.getQueryHash(name) + '/query', query)
index = self.presetCombo.findText(name)
if index == -1:
self.presetCombo.addItem(name)
self.presetCombo.setCurrentIndex(self.presetCombo.count() - 1)
else:
self.presetCombo.setCurrentIndex(index)
def saveAsFilePreset(self):
settings = QgsSettings()
lastDir = settings.value('DB_Manager/lastDirSQLFIle', "")
query = self.editSql.text()
if query == "":
return
filename, _ = QFileDialog.getSaveFileName(
self,
self.tr('Save SQL Query'),
lastDir,
self.tr("SQL File (*.sql *.SQL)"))
if filename:
if not filename.lower().endswith('.sql'):
filename += ".sql"
with open(filename, 'w') as f:
f.write(query)
lastDir = os.path.dirname(filename)
settings.setValue('DB_Manager/lastDirSQLFile', lastDir)
def loadFilePreset(self):
settings = QgsSettings()
lastDir = settings.value('DB_Manager/lastDirSQLFIle', "")
filename, _ = QFileDialog.getOpenFileName(
self,
self.tr("Load SQL Query"),
lastDir,
self.tr("SQL File (*.sql *.SQL);;All Files (*)"))
if filename:
with open(filename, 'r') as f:
self.editSql.clear()
for line in f:
self.editSql.insertText(line)
lastDir = os.path.dirname(filename)
settings.setValue('DB_Manager/lastDirSQLFile', lastDir)
def deletePreset(self):
name = self.presetCombo.currentText()
QgsProject.instance().removeEntry('DBManager', 'savedQueries/' + self.getQueryHash(name))
self.presetCombo.removeItem(self.presetCombo.findText(name))
self.presetCombo.setCurrentIndex(-1)
def loadPreset(self, name):
query = QgsProject.instance().readEntry('DBManager', 'savedQueries/' + self.getQueryHash(name) + '/query')[0]
self.editSql.setText(query)
def loadAsLayerToggled(self, checked):
self.loadAsLayerGroup.setChecked(checked)
self.loadAsLayerWidget.setVisible(checked)
if checked:
self.fillColumnCombos()
def clearSql(self):
self.editSql.clear()
self.editSql.setFocus()
self.filter = ""
def updateUiWhileSqlExecution(self, status):
if status:
for i in range(0, self.mainWindow.tabs.count()):
if i != self.mainWindow.tabs.currentIndex():
self.mainWindow.tabs.setTabEnabled(i, False)
self.mainWindow.menuBar.setEnabled(False)
self.mainWindow.toolBar.setEnabled(False)
self.mainWindow.tree.setEnabled(False)
for w in self.findChildren(QWidget):
w.setEnabled(False)
self.btnCancel.setEnabled(True)
self.progressBar.setEnabled(True)
self.progressBar.setRange(0, 0)
else:
for i in range(0, self.mainWindow.tabs.count()):
if i != self.mainWindow.tabs.currentIndex():
self.mainWindow.tabs.setTabEnabled(i, True)
self.mainWindow.refreshTabs()
self.mainWindow.menuBar.setEnabled(True)
self.mainWindow.toolBar.setEnabled(True)
self.mainWindow.tree.setEnabled(True)
for w in self.findChildren(QWidget):
w.setEnabled(True)
self.btnCancel.setEnabled(False)
self.progressBar.setRange(0, 100)
self.progressBar.setEnabled(False)
def executeSqlCanceled(self):
self.btnCancel.setEnabled(False)
self.modelAsync.cancel()
def executeSqlCompleted(self):
self.updateUiWhileSqlExecution(False)
with OverrideCursor(Qt.WaitCursor):
if self.modelAsync.task.status() == QgsTask.Complete:
model = self.modelAsync.model
quotedCols = []
self.viewResult.setModel(model)
self.lblResult.setText(self.tr("{0} rows, {1:.3f} seconds").format(model.affectedRows(), model.secs()))
cols = self.viewResult.model().columnNames()
for col in cols:
quotedCols.append(self.db.connector.quoteId(col))
self.setColumnCombos(cols, quotedCols)
self.writeQueryHistory(self.modelAsync.task.sql, model.affectedRows(), model.secs())
self.update()
elif not self.modelAsync.canceled:
DlgDbError.showError(self.modelAsync.error, self)
self.uniqueModel.clear()
self.geomCombo.clear()
def executeSql(self):
sql = self._getExecutableSqlQuery()
if sql == "":
return
# delete the old model
old_model = self.viewResult.model()
self.viewResult.setModel(None)
if old_model:
old_model.deleteLater()
try:
self.modelAsync = self.db.sqlResultModelAsync(sql, self)
self.modelAsync.done.connect(self.executeSqlCompleted)
self.updateUiWhileSqlExecution(True)
QgsApplication.taskManager().addTask(self.modelAsync.task)
except Exception as e:
DlgDbError.showError(e, self)
self.uniqueModel.clear()
self.geomCombo.clear()
return
def _getSqlLayer(self, _filter):
hasUniqueField = self.uniqueColumnCheck.checkState() == Qt.Checked
if hasUniqueField:
if self.allowMultiColumnPk:
checkedCols = []
for item in self.uniqueModel.findItems("*", Qt.MatchWildcard):
if item.checkState() == Qt.Checked:
checkedCols.append(item.data())
uniqueFieldName = ",".join(checkedCols)
elif self.uniqueCombo.currentIndex() >= 0:
uniqueFieldName = self.uniqueModel.item(self.uniqueCombo.currentIndex()).data()
else:
uniqueFieldName = None
else:
uniqueFieldName = None
hasGeomCol = self.hasGeometryCol.checkState() == Qt.Checked
if hasGeomCol:
geomFieldName = self.geomCombo.currentText()
else:
geomFieldName = None
query = self._getExecutableSqlQuery()
if query == "":
return None
# remove a trailing ';' from query if present
if query.strip().endswith(';'):
query = query.strip()[:-1]
layerType = QgsMapLayerType.VectorLayer if self.vectorRadio.isChecked() else QgsMapLayerType.RasterLayer
# get a new layer name
names = []
for layer in list(QgsProject.instance().mapLayers().values()):
names.append(layer.name())
layerName = self.layerNameEdit.text()
if layerName == "":
layerName = self.defaultLayerName
newLayerName = layerName
index = 1
while newLayerName in names:
index += 1
newLayerName = u"%s_%d" % (layerName, index)
# create the layer
layer = self.db.toSqlLayer(query, geomFieldName, uniqueFieldName, newLayerName, layerType,
self.avoidSelectById.isChecked(), _filter)
if layer.isValid():
return layer
else:
e = BaseError(self.tr("There was an error creating the SQL layer, please check the logs for further information."))
DlgDbError.showError(e, self)
return None
def loadSqlLayer(self):
with OverrideCursor(Qt.WaitCursor):
layer = self._getSqlLayer(self.filter)
if layer is None:
return
QgsProject.instance().addMapLayers([layer], True)
def fillColumnCombos(self):
query = self._getExecutableSqlQuery()
if query == "":
return
with OverrideCursor(Qt.WaitCursor):
# remove a trailing ';' from query if present
if query.strip().endswith(';'):
query = query.strip()[:-1]
# get all the columns
quotedCols = []
connector = self.db.connector
if self.aliasSubQuery:
# get a new alias
aliasIndex = 0
while True:
alias = "_subQuery__%d" % aliasIndex
escaped = re.compile('\\b("?)' + re.escape(alias) + '\\1\\b')
if not escaped.search(query):
break
aliasIndex += 1
sql = u"SELECT * FROM (%s\n) AS %s LIMIT 0" % (str(query), connector.quoteId(alias))
else:
sql = u"SELECT * FROM (%s\n) WHERE 1=0" % str(query)
c = None
try:
c = connector._execute(None, sql)
cols = connector._get_cursor_columns(c)
for col in cols:
quotedCols.append(connector.quoteId(col))
except BaseError as e:
DlgDbError.showError(e, self)
self.uniqueModel.clear()
self.geomCombo.clear()
return
finally:
if c:
c.close()
del c
self.setColumnCombos(cols, quotedCols)
def setColumnCombos(self, cols, quotedCols):
# get sensible default columns. do this before sorting in case there's hints in the column order (e.g., id is more likely to be first)
try:
defaultGeomCol = next(col for col in cols if col in ['geom', 'geometry', 'the_geom', 'way'])
except:
defaultGeomCol = None
try:
defaultUniqueCol = [col for col in cols if 'id' in col][0]
except:
defaultUniqueCol = None
colNames = sorted(zip(cols, quotedCols))
newItems = []
uniqueIsFilled = False
for (col, quotedCol) in colNames:
item = QStandardItem(col)
item.setData(quotedCol)
item.setEnabled(True)
item.setCheckable(self.allowMultiColumnPk)
item.setSelectable(not self.allowMultiColumnPk)
if self.allowMultiColumnPk:
matchingItems = self.uniqueModel.findItems(col)
if matchingItems:
item.setCheckState(matchingItems[0].checkState())
uniqueIsFilled = uniqueIsFilled or matchingItems[0].checkState() == Qt.Checked
else:
item.setCheckState(Qt.Unchecked)
newItems.append(item)
if self.allowMultiColumnPk:
self.uniqueModel.clear()
self.uniqueModel.appendColumn(newItems)
self.uniqueChanged()
else:
previousUniqueColumn = self.uniqueCombo.currentText()
self.uniqueModel.clear()
self.uniqueModel.appendColumn(newItems)
if self.uniqueModel.findItems(previousUniqueColumn):
self.uniqueCombo.setEditText(previousUniqueColumn)
uniqueIsFilled = True
oldGeometryColumn = self.geomCombo.currentText()
self.geomCombo.clear()
self.geomCombo.addItems(cols)
self.geomCombo.setCurrentIndex(self.geomCombo.findText(oldGeometryColumn, Qt.MatchExactly))
# set sensible default columns if the columns are not already set
try:
if self.geomCombo.currentIndex() == -1:
self.geomCombo.setCurrentIndex(cols.index(defaultGeomCol))
except:
pass
items = self.uniqueModel.findItems(defaultUniqueCol)
if items and not uniqueIsFilled:
if self.allowMultiColumnPk:
items[0].setCheckState(Qt.Checked)
else:
self.uniqueCombo.setEditText(defaultUniqueCol)
def copySelectedResults(self):
if len(self.viewResult.selectedIndexes()) <= 0:
return
model = self.viewResult.model()
# convert to string using tab as separator
text = model.headerToString("\t")
for idx in self.viewResult.selectionModel().selectedRows():
text += "\n" + model.rowToString(idx.row(), "\t")
QApplication.clipboard().setText(text, QClipboard.Selection)
QApplication.clipboard().setText(text, QClipboard.Clipboard)
def initCompleter(self):
dictionary = None
if self.db:
dictionary = self.db.connector.getSqlDictionary()
if not dictionary:
# use the generic sql dictionary
from .sql_dictionary import getSqlDictionary
dictionary = getSqlDictionary()
wordlist = []
for value in dictionary.values():
wordlist += value # concat lists
wordlist = list(set(wordlist)) # remove duplicates
api = QsciAPIs(self.editSql.lexer())
for word in wordlist:
api.add(word)
api.prepare()
self.editSql.lexer().setAPIs(api)
def displayQueryBuilder(self):
dlg = QueryBuilderDlg(self.iface, self.db, self, reset=self.queryBuilderFirst)
self.queryBuilderFirst = False
r = dlg.exec_()
if r == QDialog.Accepted:
self.editSql.setText(dlg.query)
def createView(self):
name, ok = QInputDialog.getText(None, self.tr("View Name"), self.tr("View name"))
if ok:
try:
self.db.connector.createSpatialView(name, self._getExecutableSqlQuery())
except BaseError as e:
DlgDbError.showError(e, self)
def _getSqlQuery(self):
sql = self.editSql.selectedText()
if len(sql) == 0:
sql = self.editSql.text()
return sql
def _getExecutableSqlQuery(self):
sql = self._getSqlQuery()
uncommented_sql = check_comments_in_sql(sql)
return uncommented_sql
def uniqueChanged(self):
# when an item is (un)checked, simply trigger an update of the combobox text
self.uniqueTextChanged(None)
def uniqueTextChanged(self, text):
# Whenever there is new text displayed in the combobox, check if it is the correct one and if not, display the correct one.
checkedItems = []
for item in self.uniqueModel.findItems("*", Qt.MatchWildcard):
if item.checkState() == Qt.Checked:
checkedItems.append(item.text())
label = ", ".join(checkedItems)
if text != label:
self.uniqueCombo.setEditText(label)
def setFilter(self):
from qgis.gui import QgsQueryBuilder
layer = self._getSqlLayer("")
if not layer:
return
dlg = QgsQueryBuilder(layer)
dlg.setSql(self.filter)
if dlg.exec_():
self.filter = dlg.sql()
layer.deleteLater()
class DlgSqlLayerWindow(QWidget, Ui_Dialog):
nameChanged = pyqtSignal(str)
def __init__(self, iface, layer, parent=None):
QWidget.__init__(self, parent)
self.iface = iface
self.layer = layer
uri = QgsDataSourceUri(layer.source())
dbplugin = None
db = None
if layer.dataProvider().name() == 'postgres':
dbplugin = createDbPlugin('postgis', 'postgres')
elif layer.dataProvider().name() == 'spatialite':
dbplugin = createDbPlugin('spatialite', 'spatialite')
elif layer.dataProvider().name() == 'oracle':
dbplugin = createDbPlugin('oracle', 'oracle')
elif layer.dataProvider().name() == 'virtual':
dbplugin = createDbPlugin('vlayers', 'virtual')
elif layer.dataProvider().name() == 'ogr':
dbplugin = createDbPlugin('gpkg', 'gpkg')
if dbplugin:
dbplugin.connectToUri(uri)
db = dbplugin.db
self.dbplugin = dbplugin
self.db = db
self.filter = ""
self.allowMultiColumnPk = isinstance(db, PGDatabase) # at the moment only PostgreSQL allows a primary key to span multiple columns, SpatiaLite doesn't
self.aliasSubQuery = isinstance(db, PGDatabase) # only PostgreSQL requires subqueries to be aliases
self.setupUi(self)
self.setWindowTitle(
u"%s - %s [%s]" % (self.windowTitle(), db.connection().connectionName(), db.connection().typeNameString()))
self.defaultLayerName = 'QueryLayer'
if self.allowMultiColumnPk:
self.uniqueColumnCheck.setText(self.tr("Column(s) with unique values"))
else:
self.uniqueColumnCheck.setText(self.tr("Column with unique values"))
self.editSql.setFocus()
self.editSql.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.editSql.setMarginVisible(True)
self.initCompleter()
# allow copying results
copyAction = QAction("copy", self)
self.viewResult.addAction(copyAction)
copyAction.setShortcuts(QKeySequence.Copy)
copyAction.triggered.connect(self.copySelectedResults)
self.btnExecute.clicked.connect(self.executeSql)
self.btnSetFilter.clicked.connect(self.setFilter)
self.btnClear.clicked.connect(self.clearSql)
self.presetStore.clicked.connect(self.storePreset)
self.presetDelete.clicked.connect(self.deletePreset)
self.presetCombo.activated[str].connect(self.loadPreset)
self.presetCombo.activated[str].connect(self.presetName.setText)
self.editSql.textChanged.connect(self.updatePresetButtonsState)
self.presetName.textChanged.connect(self.updatePresetButtonsState)
self.presetCombo.currentIndexChanged.connect(self.updatePresetButtonsState)
self.updatePresetsCombobox()
self.geomCombo.setEditable(True)
self.geomCombo.lineEdit().setReadOnly(True)
self.uniqueCombo.setEditable(True)
self.uniqueCombo.lineEdit().setReadOnly(True)
self.uniqueModel = QStandardItemModel(self.uniqueCombo)
self.uniqueCombo.setModel(self.uniqueModel)
if self.allowMultiColumnPk:
self.uniqueCombo.setItemDelegate(QStyledItemDelegate())
self.uniqueModel.itemChanged.connect(self.uniqueChanged) # react to the (un)checking of an item
self.uniqueCombo.lineEdit().textChanged.connect(self.uniqueTextChanged) # there are other events that change the displayed text and some of them can not be caught directly
self.layerTypeWidget.hide() # show if load as raster is supported
# self.loadLayerBtn.clicked.connect(self.loadSqlLayer)
self.updateLayerBtn.clicked.connect(self.updateSqlLayer)
self.getColumnsBtn.clicked.connect(self.fillColumnCombos)
self.queryBuilderFirst = True
self.queryBuilderBtn.setIcon(QIcon(":/db_manager/icons/sql.gif"))
self.queryBuilderBtn.clicked.connect(self.displayQueryBuilder)
self.presetName.textChanged.connect(self.nameChanged)
# Update from layer
# First the SQL from QgsDataSourceUri table
sql = uri.table()
if uri.keyColumn() == '_uid_':
match = re.search(r'^\(SELECT .+ AS _uid_,\* FROM \((.*)\) AS _subq_.+_\s*\)$', sql, re.S | re.X)
if match:
sql = match.group(1)
else:
match = re.search(r'^\((SELECT .+ FROM .+)\)$', sql, re.S | re.X)
if match:
sql = match.group(1)
# Need to check on table() since the parentheses were removed by the regexp
if not uri.table().startswith('(') and not uri.table().endswith(')'):
schema = uri.schema()
if schema and schema.upper() != 'PUBLIC':
sql = 'SELECT * FROM {0}.{1}'.format(self.db.connector.quoteId(schema), self.db.connector.quoteId(sql))
else:
sql = 'SELECT * FROM {0}'.format(self.db.connector.quoteId(sql))
self.editSql.setText(sql)
self.executeSql()
# Then the columns
self.geomCombo.setCurrentIndex(self.geomCombo.findText(uri.geometryColumn(), Qt.MatchExactly))
if uri.keyColumn() != '_uid_':
self.uniqueColumnCheck.setCheckState(Qt.Checked)
if self.allowMultiColumnPk:
itemsData = uri.keyColumn().split(',')
for item in self.uniqueModel.findItems("*", Qt.MatchWildcard):
if item.data() in itemsData:
item.setCheckState(Qt.Checked)
else:
keyColumn = uri.keyColumn()
if self.uniqueModel.findItems(keyColumn):
self.uniqueCombo.setEditText(keyColumn)
# Finally layer name, filter and selectAtId
self.layerNameEdit.setText(layer.name())
self.filter = uri.sql()
if uri.selectAtIdDisabled():
self.avoidSelectById.setCheckState(Qt.Checked)
def getQueryHash(self, name):
return 'q%s' % md5(name.encode('utf8')).hexdigest()
def updatePresetButtonsState(self, *args):
"""Slot called when the combo box or the sql or the query name have changed:
sets store button state"""
self.presetStore.setEnabled(bool(self._getSqlQuery() and self.presetName.text()))
self.presetDelete.setEnabled(bool(self.presetCombo.currentIndex() != -1))
def updatePresetsCombobox(self):
self.presetCombo.clear()
names = []
entries = QgsProject.instance().subkeyList('DBManager', 'savedQueries')
for entry in entries:
name = QgsProject.instance().readEntry('DBManager', 'savedQueries/' + entry + '/name')[0]
names.append(name)
for name in sorted(names):
self.presetCombo.addItem(name)
self.presetCombo.setCurrentIndex(-1)
def storePreset(self):
query = self._getSqlQuery()
if query == "":
return
name = self.presetName.text()
QgsProject.instance().writeEntry('DBManager', 'savedQueries/' + self.getQueryHash(name) + '/name', name)
QgsProject.instance().writeEntry('DBManager', 'savedQueries/' + self.getQueryHash(name) + '/query', query)
index = self.presetCombo.findText(name)
if index == -1:
self.presetCombo.addItem(name)
self.presetCombo.setCurrentIndex(self.presetCombo.count() - 1)
else:
self.presetCombo.setCurrentIndex(index)
def deletePreset(self):
name = self.presetCombo.currentText()
QgsProject.instance().removeEntry('DBManager', 'savedQueries/q' + self.getQueryHash(name))
self.presetCombo.removeItem(self.presetCombo.findText(name))
self.presetCombo.setCurrentIndex(-1)
def loadPreset(self, name):
query = QgsProject.instance().readEntry('DBManager', 'savedQueries/' + self.getQueryHash(name) + '/query')[0]
name = QgsProject.instance().readEntry('DBManager', 'savedQueries/' + self.getQueryHash(name) + '/name')[0]
self.editSql.setText(query)
def clearSql(self):
self.editSql.clear()
self.editSql.setFocus()
self.filter = ""
def executeSql(self):
sql = self._getSqlQuery()
if sql == "":
return
with OverrideCursor(Qt.WaitCursor):
# delete the old model
old_model = self.viewResult.model()
self.viewResult.setModel(None)
if old_model:
old_model.deleteLater()
cols = []
quotedCols = []
try:
# set the new model
model = self.db.sqlResultModel(sql, self)
self.viewResult.setModel(model)
self.lblResult.setText(self.tr("{0} rows, {1:.3f} seconds").format(model.affectedRows(), model.secs()))
cols = self.viewResult.model().columnNames()
for col in cols:
quotedCols.append(self.db.connector.quoteId(col))
except BaseError as e:
DlgDbError.showError(e, self)
self.uniqueModel.clear()
self.geomCombo.clear()
return
self.setColumnCombos(cols, quotedCols)
self.update()
def _getSqlLayer(self, _filter):
hasUniqueField = self.uniqueColumnCheck.checkState() == Qt.Checked
if hasUniqueField:
if self.allowMultiColumnPk:
checkedCols = []
for item in self.uniqueModel.findItems("*", Qt.MatchWildcard):
if item.checkState() == Qt.Checked:
checkedCols.append(item.data())
uniqueFieldName = ",".join(checkedCols)
elif self.uniqueCombo.currentIndex() >= 0:
uniqueFieldName = self.uniqueModel.item(self.uniqueCombo.currentIndex()).data()
else:
uniqueFieldName = None
else:
uniqueFieldName = None
hasGeomCol = self.hasGeometryCol.checkState() == Qt.Checked
if hasGeomCol:
geomFieldName = self.geomCombo.currentText()
else:
geomFieldName = None
query = self._getSqlQuery()
if query == "":
return None
# remove a trailing ';' from query if present
if query.strip().endswith(';'):
query = query.strip()[:-1]
from qgis.core import QgsMapLayer
layerType = QgsMapLayer.VectorLayer if self.vectorRadio.isChecked() else QgsMapLayer.RasterLayer
# get a new layer name
names = []
for layer in list(QgsProject.instance().mapLayers().values()):
names.append(layer.name())
layerName = self.layerNameEdit.text()
if layerName == "":
layerName = self.defaultLayerName
newLayerName = layerName
index = 1
while newLayerName in names:
index += 1
newLayerName = u"%s_%d" % (layerName, index)
# create the layer
layer = self.db.toSqlLayer(query, geomFieldName, uniqueFieldName, newLayerName, layerType,
self.avoidSelectById.isChecked(), _filter)
if layer.isValid():
return layer
else:
return None
def loadSqlLayer(self):
with OverrideCursor(Qt.WaitCursor):
layer = self._getSqlLayer(self.filter)
if layer is None:
return
QgsProject.instance().addMapLayers([layer], True)
def updateSqlLayer(self):
with OverrideCursor(Qt.WaitCursor):
layer = self._getSqlLayer(self.filter)
if layer is None:
return
# self.layer.dataProvider().setDataSourceUri(layer.dataProvider().dataSourceUri())
# self.layer.dataProvider().reloadData()
XMLDocument = QDomDocument("style")
XMLMapLayers = XMLDocument.createElement("maplayers")
XMLMapLayer = XMLDocument.createElement("maplayer")
self.layer.writeLayerXml(XMLMapLayer, XMLDocument, QgsReadWriteContext())
XMLMapLayer.firstChildElement("datasource").firstChild().setNodeValue(layer.source())
XMLMapLayers.appendChild(XMLMapLayer)
XMLDocument.appendChild(XMLMapLayers)
self.layer.readLayerXml(XMLMapLayer, QgsReadWriteContext())
self.layer.reload()
self.iface.actionDraw().trigger()
self.iface.mapCanvas().refresh()
def fillColumnCombos(self):
query = self._getSqlQuery()
if query == "":
return
with OverrideCursor(Qt.WaitCursor):
# remove a trailing ';' from query if present
if query.strip().endswith(';'):
query = query.strip()[:-1]
# get all the columns
cols = []
quotedCols = []
connector = self.db.connector
if self.aliasSubQuery:
# get a new alias
aliasIndex = 0
while True:
alias = "_subQuery__%d" % aliasIndex
escaped = re.compile('\\b("?)' + re.escape(alias) + '\\1\\b')
if not escaped.search(query):
break
aliasIndex += 1
sql = u"SELECT * FROM (%s\n) AS %s LIMIT 0" % (str(query), connector.quoteId(alias))
else:
sql = u"SELECT * FROM (%s\n) WHERE 1=0" % str(query)
c = None
try:
c = connector._execute(None, sql)
cols = connector._get_cursor_columns(c)
for col in cols:
quotedCols.append(connector.quoteId(col))
except BaseError as e:
DlgDbError.showError(e, self)
self.uniqueModel.clear()
self.geomCombo.clear()
return
finally:
if c:
c.close()
del c
self.setColumnCombos(cols, quotedCols)
def setColumnCombos(self, cols, quotedCols):
# get sensible default columns. do this before sorting in case there's hints in the column order (e.g., id is more likely to be first)
try:
defaultGeomCol = next(col for col in cols if col in ['geom', 'geometry', 'the_geom', 'way'])
except:
defaultGeomCol = None
try:
defaultUniqueCol = [col for col in cols if 'id' in col][0]
except:
defaultUniqueCol = None
colNames = sorted(zip(cols, quotedCols))
newItems = []
uniqueIsFilled = False
for (col, quotedCol) in colNames:
item = QStandardItem(col)
item.setData(quotedCol)
item.setEnabled(True)
item.setCheckable(self.allowMultiColumnPk)
item.setSelectable(not self.allowMultiColumnPk)
if self.allowMultiColumnPk:
matchingItems = self.uniqueModel.findItems(col)
if matchingItems:
item.setCheckState(matchingItems[0].checkState())
uniqueIsFilled = uniqueIsFilled or matchingItems[0].checkState() == Qt.Checked
else:
item.setCheckState(Qt.Unchecked)
newItems.append(item)
if self.allowMultiColumnPk:
self.uniqueModel.clear()
self.uniqueModel.appendColumn(newItems)
self.uniqueChanged()
else:
previousUniqueColumn = self.uniqueCombo.currentText()
self.uniqueModel.clear()
self.uniqueModel.appendColumn(newItems)
if self.uniqueModel.findItems(previousUniqueColumn):
self.uniqueCombo.setEditText(previousUniqueColumn)
uniqueIsFilled = True
oldGeometryColumn = self.geomCombo.currentText()
self.geomCombo.clear()
self.geomCombo.addItems(cols)
self.geomCombo.setCurrentIndex(self.geomCombo.findText(oldGeometryColumn, Qt.MatchExactly))
# set sensible default columns if the columns are not already set
try:
if self.geomCombo.currentIndex() == -1:
self.geomCombo.setCurrentIndex(cols.index(defaultGeomCol))
except:
pass
items = self.uniqueModel.findItems(defaultUniqueCol)
if items and not uniqueIsFilled:
if self.allowMultiColumnPk:
items[0].setCheckState(Qt.Checked)
else:
self.uniqueCombo.setEditText(defaultUniqueCol)
try:
pass
except:
pass
def copySelectedResults(self):
if len(self.viewResult.selectedIndexes()) <= 0:
return
model = self.viewResult.model()
# convert to string using tab as separator
text = model.headerToString("\t")
for idx in self.viewResult.selectionModel().selectedRows():
text += "\n" + model.rowToString(idx.row(), "\t")
QApplication.clipboard().setText(text, QClipboard.Selection)
QApplication.clipboard().setText(text, QClipboard.Clipboard)
def initCompleter(self):
dictionary = None
if self.db:
dictionary = self.db.connector.getSqlDictionary()
if not dictionary:
# use the generic sql dictionary
from .sql_dictionary import getSqlDictionary
dictionary = getSqlDictionary()
wordlist = []
for name, value in dictionary.items():
wordlist += value # concat lists
wordlist = list(set(wordlist)) # remove duplicates
api = QsciAPIs(self.editSql.lexer())
for word in wordlist:
api.add(word)
api.prepare()
self.editSql.lexer().setAPIs(api)
def displayQueryBuilder(self):
dlg = QueryBuilderDlg(self.iface, self.db, self, reset=self.queryBuilderFirst)
self.queryBuilderFirst = False
r = dlg.exec_()
if r == QDialog.Accepted:
self.editSql.setText(dlg.query)
def _getSqlQuery(self):
sql = self.editSql.selectedText()
if len(sql) == 0:
sql = self.editSql.text()
return sql
def uniqueChanged(self):
# when an item is (un)checked, simply trigger an update of the combobox text
self.uniqueTextChanged(None)
def uniqueTextChanged(self, text):
# Whenever there is new text displayed in the combobox, check if it is the correct one and if not, display the correct one.
checkedItems = []
for item in self.uniqueModel.findItems("*", Qt.MatchWildcard):
if item.checkState() == Qt.Checked:
checkedItems.append(item.text())
label = ", ".join(checkedItems)
if text != label:
self.uniqueCombo.setEditText(label)
def setFilter(self):
from qgis.gui import QgsQueryBuilder
layer = self._getSqlLayer("")
if not layer:
return
dlg = QgsQueryBuilder(layer)
dlg.setSql(self.filter)
if dlg.exec_():
self.filter = dlg.sql()
layer.deleteLater()
class MultipleSelectTreeView(QListView):
"""
Custom QListView implementation that displays checkable items from a
multiple select column type.
"""
def __init__(self, column, parent=None):
"""
Class constructor.
:param column: Multiple select column object.
:type column: MultipleSelectColumn
:param parent: Parent widget for the control.
:type parent: QWidget
"""
QListView.__init__(self, parent)
# Disable editing of lookup values
self.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.column = column
self._item_model = QStandardItemModel(self)
self._value_list = self.column.value_list
# Stores lookup objects based on primary keys
self._lookup_cache = {}
self._initialize()
self._association = self.column.association
self._first_parent_col = self._association.first_reference_column.name
self._second_parent_col = self._association.second_reference_column.name
# Association model
self._assoc_cls = entity_model(self._association)
def reset_model(self):
"""
Resets the item model.
"""
self._item_model.clear()
self._item_model.setColumnCount(2)
def clear(self):
"""
Clears all items in the model.
"""
self._item_model.clear()
@property
def association(self):
"""
:return: Returns the association object corresponding to the column.
:rtype: AssociationEntity
"""
return self._association
@property
def value_list(self):
"""
:return: Returns the ValueList object corresponding to the configured
column object.
:rtype: ValueList
"""
return self._value_list
@property
def item_model(self):
"""
:return: Returns the model corresponding to the checkable items.
:rtype: QStandardItemModel
"""
return self._item_model
def _add_item(self, id, value):
"""
Adds a row corresponding to id and corresponding value from a lookup
table.
:param id: Primary key of a lookup record.
:type id: int
:param value: Lookup value
:type value: str
"""
value_item = QStandardItem(value)
value_item.setCheckable(True)
id_item = QStandardItem(str(id))
self._item_model.appendRow([value_item, id_item])
def _initialize(self):
# Populate list with lookup items
self.reset_model()
# Add all lookup values in the value list table
vl_cls = entity_model(self._value_list)
if not vl_cls is None:
vl_obj = vl_cls()
res = vl_obj.queryObject().all()
for r in res:
self._lookup_cache[r.id] = r
self._add_item(r.id, r.value)
self.setModel(self._item_model)
def clear_selection(self):
"""
Unchecks all items in the view.
"""
for i in range(self._item_model.rowCount()):
value_item = self._item_model.item(i, 0)
if value_item.checkState() == Qt.Checked:
value_item.setCheckState(Qt.Unchecked)
if value_item.rowCount() > 0:
value_item.removeRow(0)
def selection(self):
"""
:return: Returns a list of selected items.
:rtype: list
"""
selection = []
for i in range(self._item_model.rowCount()):
value_item = self._item_model.item(i, 0)
if value_item.checkState() == Qt.Checked:
id_item = self._item_model.item(i, 1)
id = int(id_item.text())
# Get item from the lookup cache and append to selection
if id in self._lookup_cache:
lookup_rec = self._lookup_cache[id]
selection.append(lookup_rec)
return selection
def set_selection(self, models):
"""
Checks items corresponding to the specified models.
:param models: List containing model values in the view for selection.
:type models: list
"""
for m in models:
search_value = m.value
v_items = self._item_model.findItems(search_value)
# Loop through result and check items
for vi in v_items:
if vi.checkState() == Qt.Unchecked:
vi.setCheckState(Qt.Checked)
class ConfigDialog(BASE, WIDGET):
def __init__(self, toolbox):
super(ConfigDialog, self).__init__(None)
self.setupUi(self)
self.toolbox = toolbox
self.groupIcon = QIcon()
self.groupIcon.addPixmap(
self.style().standardPixmap(QStyle.SP_DirClosedIcon), QIcon.Normal,
QIcon.Off)
self.groupIcon.addPixmap(
self.style().standardPixmap(QStyle.SP_DirOpenIcon), QIcon.Normal,
QIcon.On)
if hasattr(self.searchBox, 'setPlaceholderText'):
self.searchBox.setPlaceholderText(self.tr('Search...'))
self.model = QStandardItemModel()
self.tree.setModel(self.model)
self.delegate = SettingDelegate()
self.tree.setItemDelegateForColumn(1, self.delegate)
self.searchBox.textChanged.connect(self.textChanged)
self.fillTree()
self.tree.expanded.connect(self.adjustColumns)
def textChanged(self):
text = unicode(self.searchBox.text().lower())
self._filterItem(self.model.invisibleRootItem(), text)
if text:
self.tree.expandAll()
else:
self.tree.collapseAll()
def _filterItem(self, item, text):
if item.hasChildren():
show = False
for i in xrange(item.rowCount()):
child = item.child(i)
showChild = self._filterItem(child, text)
show = (showChild or show)
self.tree.setRowHidden(item.row(), item.index().parent(), not show)
return show
elif isinstance(item, QStandardItem):
hide = bool(text) and (text not in item.text().lower())
self.tree.setRowHidden(item.row(), item.index().parent(), hide)
return not hide
def fillTree(self):
self.fillTreeUsingProviders()
def fillTreeUsingProviders(self):
self.items = {}
self.model.clear()
self.model.setHorizontalHeaderLabels(
[self.tr('Setting'), self.tr('Value')])
settings = ProcessingConfig.getSettings()
rootItem = self.model.invisibleRootItem()
"""
Filter 'General', 'Models' and 'Scripts' items
"""
priorityKeys = [
self.tr('General'),
self.tr('Models'),
self.tr('Scripts')
]
for group in priorityKeys:
groupItem = QStandardItem(group)
icon = ProcessingConfig.getGroupIcon(group)
groupItem.setIcon(icon)
groupItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [groupItem, emptyItem])
# add menu item only if it has any search matches
for setting in settings[group]:
if setting.hidden or setting.name.startswith("MENU_"):
continue
labelItem = QStandardItem(setting.description)
labelItem.setIcon(icon)
labelItem.setEditable(False)
self.items[setting] = SettingItem(setting)
groupItem.insertRow(0, [labelItem, self.items[setting]])
"""
Filter 'Providers' items
"""
providersItem = QStandardItem(self.tr('Providers'))
icon = QIcon(os.path.join(pluginPath, 'images', 'alg.png'))
providersItem.setIcon(icon)
providersItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [providersItem, emptyItem])
for group in settings.keys():
if group in priorityKeys or group == menusSettingsGroup:
continue
groupItem = QStandardItem(group)
icon = ProcessingConfig.getGroupIcon(group)
groupItem.setIcon(icon)
groupItem.setEditable(False)
for setting in settings[group]:
if setting.hidden:
continue
labelItem = QStandardItem(setting.description)
labelItem.setIcon(icon)
labelItem.setEditable(False)
self.items[setting] = SettingItem(setting)
groupItem.insertRow(0, [labelItem, self.items[setting]])
emptyItem = QStandardItem()
emptyItem.setEditable(False)
providersItem.appendRow([groupItem, emptyItem])
"""
Filter 'Menus' items
"""
menusItem = QStandardItem(self.tr('Menus (requires restart)'))
icon = QIcon(os.path.join(pluginPath, 'images', 'menu.png'))
menusItem.setIcon(icon)
menusItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [menusItem, emptyItem])
providers = Processing.providers
for provider in providers:
providerDescription = provider.getDescription()
groupItem = QStandardItem(providerDescription)
icon = provider.getIcon()
groupItem.setIcon(icon)
groupItem.setEditable(False)
for alg in provider.algs:
algItem = QStandardItem(alg.i18n_name or alg.name)
algItem.setIcon(icon)
algItem.setEditable(False)
try:
settingMenu = ProcessingConfig.settings[
"MENU_" + alg.commandLineName()]
settingButton = ProcessingConfig.settings[
"BUTTON_" + alg.commandLineName()]
settingIcon = ProcessingConfig.settings[
"ICON_" + alg.commandLineName()]
except:
continue
self.items[settingMenu] = SettingItem(settingMenu)
self.items[settingButton] = SettingItem(settingButton)
self.items[settingIcon] = SettingItem(settingIcon)
menuLabelItem = QStandardItem("Menu path")
menuLabelItem.setEditable(False)
buttonLabelItem = QStandardItem("Add button in toolbar")
buttonLabelItem.setEditable(False)
iconLabelItem = QStandardItem("Icon")
iconLabelItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
algItem.insertRow(0, [menuLabelItem, self.items[settingMenu]])
algItem.insertRow(0,
[buttonLabelItem, self.items[settingButton]])
algItem.insertRow(0, [iconLabelItem, self.items[settingIcon]])
groupItem.insertRow(0, [algItem, emptyItem])
emptyItem = QStandardItem()
emptyItem.setEditable(False)
menusItem.appendRow([groupItem, emptyItem])
self.tree.sortByColumn(0, Qt.AscendingOrder)
self.adjustColumns()
def accept(self):
for setting in self.items.keys():
if isinstance(setting.value, bool):
setting.setValue(
self.items[setting].checkState() == Qt.Checked)
else:
try:
setting.setValue(unicode(self.items[setting].text()))
except ValueError as e:
QMessageBox.warning(
self, self.tr('Wrong value'),
self.tr('Wrong value for parameter "%s":\n\n%s' %
(setting.description, unicode(e))))
return
setting.save()
Processing.updateAlgsList()
settingsWatcher.settingsChanged.emit()
updateMenus()
QDialog.accept(self)
def adjustColumns(self):
self.tree.resizeColumnToContents(0)
self.tree.resizeColumnToContents(1)
class geopunt4QgisDataCatalog(QDialog):
def __init__(self, iface):
QDialog.__init__(self, None)
self.setWindowFlags(self.windowFlags() & ~Qt.WindowContextHelpButtonHint)
self.iface = iface
# initialize locale
locale = QSettings().value("locale/userLocale", "en")
if not locale: locale = 'en'
else: locale = locale[0:2]
localePath = os.path.join(os.path.dirname(__file__), 'i18n', 'geopunt4qgis_{}.qm'.format(locale))
if os.path.exists(localePath):
self.translator = QTranslator()
self.translator.load(localePath)
QCoreApplication.installTranslator(self.translator)
self._initGui()
def _initGui(self):
"""setup the user interface"""
self.ui = Ui_geopunt4QgisDataCatalogDlg()
self.ui.setupUi(self)
# get settings
self.s = QSettings()
self.loadSettings()
self.gh = geometryHelper(self.iface)
# setup a message bar
self.bar = QgsMessageBar()
self.bar.setSizePolicy( QSizePolicy.Minimum, QSizePolicy.Fixed)
self.ui.verticalLayout.addWidget(self.bar)
self.ui.buttonBox.addButton(QPushButton("Sluiten"), QDialogButtonBox.RejectRole)
for btn in self.ui.buttonBox.buttons():
btn.setAutoDefault(0)
# vars
self.firstShow = True
self.wms = None
self.wfs = None
self.dl = None
self.zoek = ''
self.bronnen = None
self.model = QStandardItemModel(self)
self.proxyModel = QSortFilterProxyModel(self)
self.proxyModel.setSourceModel(self.model)
self.ui.resultView.setModel(self.proxyModel)
self.completer = QCompleter(self)
self.completerModel = QStringListModel(self)
self.ui.zoekTxt.setCompleter(self.completer)
self.completer.setModel(self.completerModel)
# eventhandlers
self.ui.zoekBtn.clicked.connect(self.onZoekClicked)
self.ui.addWMSbtn.clicked.connect(self.addWMS)
self.ui.addWFSbtn.clicked.connect(self.addWFS)
self.ui.DLbtn.clicked.connect(lambda: self.openUrl(self.dl))
self.ui.resultView.clicked.connect(self.resultViewClicked)
self.ui.modelFilterCbx.currentIndexChanged.connect(self.modelFilterCbxIndexChanged)
self.ui.filterWgt.setHidden(1)
self.ui.buttonBox.helpRequested.connect(self.openHelp)
self.finished.connect(self.clean)
def loadSettings(self):
self.timeout = int(self.s.value("geopunt4qgis/timeout", 15))
if settings().proxyUrl:
self.proxy = settings().proxyUrl
else:
self.proxy = ""
self.md = MDReader(self.timeout, self.proxy)
def openHelp(self):
webbrowser.open_new_tab("http://www.geopunt.be/voor-experts/geopunt-plug-ins/functionaliteiten/catalogus")
def _setModel(self, records):
self.model.clear()
records = sorted(records, key=lambda k: k['title'])
for rec in records:
title = QStandardItem(rec['title']) # 0
wms = QStandardItem(rec['wms']) # 1
downloadLink = QStandardItem(rec['download']) # 2
id = QStandardItem(rec['uuid']) # 3
abstract = QStandardItem(rec['abstract']) # 4
wfs = QStandardItem(rec['wfs']) # 5
self.model.appendRow([title, wms, downloadLink, id, abstract, wfs])
# overwrite
def show(self):
QDialog.show(self)
self.setWindowModality(0)
metadataUrl = "https://metadata.geopunt.be"
inet = internet_on(proxyUrl=self.proxy, timeout=self.timeout, testSite= metadataUrl)
if not inet:
msg = "Kan geen verbing maken met de metadata van Geopunt: {} \nMogelijke is deze site niet bereikbaar, dan zal deze tool ook niet werken.\nProbeer later opnieuw. Indien dit probleem zich blijft voordoen contacteer informatie Vlaanderen.".format(metadataUrl)
QMessageBox.warning(self.iface.mainWindow(), "Waarschuwing: kan geen verbinding maken", msg)
self.bar.pushMessage( QCoreApplication.translate("geopunt4QgisPoidialog","Waarschuwing"), msg, level=Qgis.Warning, duration=3)
return
if self.firstShow:
self.ui.GDIThemaCbx.addItems([''] + self.md.list_GDI_theme())
self.ui.organisatiesCbx.addItems([''] + self.md.list_organisations())
keywords = sorted(self.md.list_suggestionKeyword())
self.completerModel.setStringList(keywords)
self.bronnen = self.md.list_bronnen()
self.ui.bronCbx.addItems([''] + [n[1] for n in self.bronnen])
self.ui.typeCbx.addItems([''] + [n[0] for n in self.md.dataTypes])
self.ui.INSPIREannexCbx.addItems([''] + self.md.inspireannex)
self.ui.INSPIREserviceCbx.addItems([''] + self.md.inspireServiceTypes)
self.ui.INSPIREthemaCbx.addItems([''] + self.md.list_inspire_theme())
self.firstShow = False
# eventhandlers
def resultViewClicked(self):
if self.ui.resultView.selectedIndexes():
row = self.ui.resultView.selectedIndexes()[0].row()
title = self.proxyModel.data(self.proxyModel.index(row, 0))
self.wms = self.proxyModel.data(self.proxyModel.index(row, 1))
self.dl = self.proxyModel.data(self.proxyModel.index(row, 2))
self.wfs = self.proxyModel.data(self.proxyModel.index(row, 5))
uuid = self.proxyModel.data(self.proxyModel.index(row, 3))
abstract = self.proxyModel.data(self.proxyModel.index(row, 4))
self.ui.descriptionText.setText(
"""<h3>%s</h3><div>%s</div><br/><div>
<a href='https://metadata.geopunt.be/zoekdienst/apps/tabsearch/index.html?uuid=%s'>
Ga naar fiche</a></div>""" % (title, abstract, uuid))
if self.wms:
self.ui.addWMSbtn.setEnabled(1)
else:
self.ui.addWMSbtn.setEnabled(0)
if self.wfs:
self.ui.addWFSbtn.setEnabled(1)
else:
self.ui.addWFSbtn.setEnabled(0)
if self.dl:
self.ui.DLbtn.setEnabled(1)
else:
self.ui.DLbtn.setEnabled(0)
def onZoekClicked(self):
self.zoek = self.ui.zoekTxt.currentText()
self.search()
def modelFilterCbxIndexChanged(self):
value = self.ui.modelFilterCbx.currentIndex()
if value == 1:
self.filterModel(1)
elif value == 2:
self.filterModel(5)
elif value == 3:
self.filterModel(2)
else:
self.filterModel()
def filterModel(self, col=None):
if col != None:
self.proxyModel.setFilterKeyColumn(col)
expr = QRegExp("?*", Qt.CaseInsensitive, QRegExp.Wildcard)
self.proxyModel.setFilterRegExp(expr)
else:
self.proxyModel.setFilterRegExp(None)
def search(self):
try:
if self.ui.filterBox.isChecked():
themekey = self.ui.GDIThemaCbx.currentText()
orgName = self.ui.organisatiesCbx.currentText()
dataTypes = [n[1] for n in self.md.dataTypes if n[0] == self.ui.typeCbx.currentText()]
if dataTypes != []:
dataType = dataTypes[0]
else:
dataType = ''
siteIds = [n[0] for n in self.bronnen if n[1] == self.ui.bronCbx.currentText()]
if siteIds != []:
siteId = siteIds[0]
else:
siteId = ''
inspiretheme = self.ui.INSPIREthemaCbx.currentText()
inspireannex = self.ui.INSPIREannexCbx.currentText()
inspireServiceType = self.ui.INSPIREserviceCbx.currentText()
searchResult = MDdata(self.md.searchAll(
self.zoek, themekey, orgName, dataType, siteId, inspiretheme, inspireannex, inspireServiceType))
else:
searchResult = MDdata(self.md.searchAll(self.zoek))
except:
self.bar.pushMessage("Error", str(sys.exc_info()[1]), level=Qgis.Critical, duration=3)
return
self.ui.countLbl.setText("Aantal gevonden: %s" % searchResult.count)
self.ui.descriptionText.setText('')
self._setModel(searchResult.records)
if searchResult.count == 0:
self.bar.pushMessage(
QCoreApplication.translate("geopunt4QgisPoidialog", "Waarschuwing "),
QCoreApplication.translate("geopunt4QgisPoidialog",
"Er werden geen resultaten gevonde voor deze zoekopdracht"),
duration=5)
def openUrl(self, url):
if url: webbrowser.open_new_tab(url.encode("utf-8"))
def addWMS(self):
if self.wms == None: return
crs = self.gh.getGetMapCrs(self.iface).authid()
if crs != 'EPSG:31370' or crs != 'EPSG:3857' or crs != 'EPSG:3043':
crs = 'EPSG:31370'
try:
lyrs = getWmsLayerNames(self.wms, self.proxy)
except:
self.bar.pushMessage("Error", str(sys.exc_info()[1]), level=Qgis.Critical, duration=10)
return
if len(lyrs) == 0:
self.bar.pushMessage("WMS",
QCoreApplication.translate("geopunt4QgisDataCatalog",
"Kan geen lagen vinden in: %s" % self.wms),
level=Qgis.Warning, duration=10)
return
elif len(lyrs) == 1:
layerTitle = lyrs[0][1]
else:
layerTitle, accept = QInputDialog.getItem(self, "WMS toevoegen",
"Kies een laag om toe te voegen", [n[1] for n in lyrs],
editable=0)
if not accept: return
layerName = [n[0] for n in lyrs if n[1] == layerTitle][0]
style = [n[2] for n in lyrs if n[1] == layerTitle][0]
if not style: style = ""
url = self.wms.split('?')[0]
if crs != 'EPSG:31370' or crs != 'EPSG:3857':
crs = 'EPSG:31370'
wmsUrl = "contextualWMSLegend=0&dpiMode=7&url=%s&layers=%s&format=image/png&styles=%s&crs=%s" % (
url, layerName, style, crs)
try:
rlayer = QgsRasterLayer(wmsUrl, layerTitle, 'wms')
if rlayer.isValid():
QgsProject.instance().addMapLayer(rlayer)
else:
self.bar.pushMessage("Error",
QCoreApplication.translate("geopunt4QgisDataCatalog", "Kan WMS niet laden"),
level=Qgis.Critical, duration=10)
except:
self.bar.pushMessage("Error", str(sys.exc_info()[1]), level=Qgis.Critical, duration=10)
return
def addWFS(self):
if self.wfs == None: return
try:
lyrs = getWFSLayerNames(self.wfs, self.proxy)
except:
self.bar.pushMessage("Error", str(sys.exc_info()[1]), level=Qgis.Critical, duration=10)
return
if len(lyrs) == 0:
self.bar.pushMessage("WFS",
QCoreApplication.translate("geopunt4QgisDataCatalog",
"Kan geen lagen vinden in: %s" % self.wfs), level=Qgis.Warning, duration=10)
return
elif len(lyrs) == 1:
layerTitle = lyrs[0][1]
else:
layerTitle, accept = QInputDialog.getItem(self, "WFS toevoegen",
"Kies een laag om toe te voegen", [n[1] for n in lyrs],
editable=0)
if not accept: return
layerName = [n[0] for n in lyrs if n[1] == layerTitle][0]
crs = [n[2] for n in lyrs if n[1] == layerTitle][0]
url = self.wfs.split('?')[0]
wfsUri = makeWFSuri(url, layerName, crs )
try:
vlayer = QgsVectorLayer(wfsUri, layerTitle, "WFS")
QgsProject.instance().addMapLayer(vlayer)
except:
self.bar.pushMessage("Error", str(sys.exc_info()[1]), level=Qgis.Critical, duration=10)
return
def clean(self):
self.model.clear()
self.wms = None
self.wfs = None
self.dl = None
self.ui.zoekTxt.setCurrentIndex(0)
self.ui.descriptionText.setText('')
self.ui.countLbl.setText("")
self.ui.msgLbl.setText("")
self.ui.DLbtn.setEnabled(0)
self.ui.addWFSbtn.setEnabled(0)
self.ui.addWMSbtn.setEnabled(0)
self.ui.modelFilterCbx.setCurrentIndex(0)
class AbstractSTREnityListView(QListView):
"""
A widget for listing and selecting one or more STR entities.
.. versionadded:: 1.7
"""
def __init__(self, parent=None, **kwargs):
super(AbstractSTREnityListView, self).__init__(parent)
self._model = QStandardItemModel(self)
self._model.setColumnCount(1)
self.setModel(self._model)
self.setEditTriggers(QAbstractItemView.NoEditTriggers)
self._model.itemChanged.connect(self._on_item_changed)
self._profile = kwargs.get('profile', None)
self._social_tenure = kwargs.get('social_tenure', None)
# Load appropriate entities to the view
if not self._profile is None:
self._load_profile_entities()
# Load entities in the STR definition
if not self._social_tenure is None:
self._select_str_entities()
def _on_item_changed(self, item):
# Emit signals when an item has been (de)selected. To be
# implemented by subclasses.
pass
@property
def profile(self):
"""
:return: Returns the current profile object in the configuration.
:rtype: Profile
"""
return self._profile
@profile.setter
def profile(self, profile):
"""
Sets the current profile object in the configuration.
:param profile: Profile object.
:type profile: Profile
"""
self._profile = profile
self._load_profile_entities()
@property
def social_tenure(self):
"""
:return: Returns the profile's social tenure entity.
:rtype: SocialTenure
"""
return self._social_tenure
@social_tenure.setter
def social_tenure(self, social_tenure):
"""
Set the social_tenure entity.
:param social_tenure: A profile's social tenure entity.
:type social_tenure: SocialTenure
"""
self._social_tenure = social_tenure
self._select_str_entities()
def _select_str_entities(self):
"""
Select the entities defined in the STR. E.g. parties for party
entity and spatial units for spatial unit entity. Default
implementation does nothing, to be implemented by subclasses.
"""
pass
def _load_profile_entities(self):
# Reset view
self.clear()
# Populate entity items in the view
for e in self._profile.user_entities():
self._add_entity(e)
def _add_entity(self, entity):
# Add entity item to view
item = QStandardItem(
GuiUtils.get_icon('table.png'),
entity.short_name
)
item.setCheckable(True)
item.setCheckState(Qt.Unchecked)
self._model.appendRow(item)
def select_entities(self, entities):
"""
Checks STR entities in the view and emit the entity_selected
signal for each item selected.
:param entities: Collection of STR entities.
:type entities: list
"""
# Clear selection
self.clear_selection()
for e in entities:
name = e.short_name
self.select_entity(name)
def selected_entities(self):
"""
:return: Returns a list of selected entity short names.
:rtype: list
"""
selected_items = []
for i in range(self._model.rowCount()):
item = self._model.item(i)
if item.checkState() == Qt.Checked:
selected_items.append(item.text())
return selected_items
def clear(self):
"""
Remove all party items in the view.
"""
self._model.clear()
self._model.setColumnCount(1)
def clear_selection(self):
"""
Uncheck all items in the view.
"""
for i in range(self._model.rowCount()):
item = self._model.item(i)
if item.checkState() == Qt.Checked:
item.setCheckState(Qt.Unchecked)
def select_entity(self, name):
"""
Selects a party entity with the given short name.
:param name: Entity short name
:type name: str
"""
items = self._model.findItems(name)
if len(items) > 0:
item = items[0]
if item.checkState() == Qt.Unchecked:
item.setCheckState(Qt.Checked)
def deselect_entity(self, name):
"""
Deselects an entity with the given short name.
:param name: Entity short name
:type name: str
"""
items = self._model.findItems(name)
if len(items) > 0:
item = items[0]
if item.checkState() == Qt.Checked:
item.setCheckState(Qt.Unchecked)
class ModelDeletionDialog(uicls, basecls):
"""Dialog for model(s) deletion."""
def __init__(self, plugin_dock, parent):
super().__init__(parent)
self.setupUi(self)
self.parent_widget = parent
self.plugin_dock = plugin_dock
self.communication = self.plugin_dock.communication
self.threedi_api = self.plugin_dock.threedi_api
self.local_schematisation = self.plugin_dock.current_local_schematisation
self.threedi_models = None
self.models_model = QStandardItemModel()
self.models_tv.setModel(self.models_model)
self.pb_delete.clicked.connect(self.delete_models)
self.pb_cancel.clicked.connect(self.reject)
self.models_tv.selectionModel().selectionChanged.connect(
self.toggle_delete_models)
self.fetch_3di_models()
def toggle_delete_models(self):
"""Toggle delete button if any model is selected."""
selection_model = self.models_tv.selectionModel()
if selection_model.hasSelection():
self.pb_delete.setEnabled(True)
else:
self.pb_delete.setDisabled(True)
def fetch_3di_models(self):
"""Fetching 3Di models list."""
try:
tc = ThreediCalls(self.threedi_api)
threedi_models, models_count = tc.fetch_3di_models_with_count(
limit=tc.FETCH_LIMIT,
schematisation_name=self.local_schematisation.name,
show_invalid=True)
self.models_model.clear()
if models_count < self.parent_widget.MAX_SCHEMATISATION_MODELS:
self.accept()
header = [
"ID", "Model", "Schematisation", "Revision", "Last updated",
"Updated by"
]
self.models_model.setHorizontalHeaderLabels(header)
for sim_model in sorted(threedi_models,
key=attrgetter("revision_commit_date"),
reverse=True):
if sim_model.schematisation_id != self.local_schematisation.id:
continue
id_item = QStandardItem(str(sim_model.id))
name_item = QStandardItem(sim_model.name)
name_item.setData(sim_model, role=Qt.UserRole)
schema_item = QStandardItem(sim_model.schematisation_name)
rev_item = QStandardItem(sim_model.revision_number)
last_updated_day = sim_model.revision_commit_date.split("T")[0]
lu_datetime = QDateTime.fromString(last_updated_day,
"yyyy-MM-dd")
lu_item = QStandardItem(lu_datetime.toString("dd-MMMM-yyyy"))
ub_item = QStandardItem(sim_model.user)
self.models_model.appendRow([
id_item, name_item, schema_item, rev_item, lu_item, ub_item
])
self.threedi_models = threedi_models
except ApiException as e:
error_msg = extract_error_message(e)
self.communication.show_error(error_msg)
except Exception as e:
error_msg = f"Error: {e}"
self.communication.show_error(error_msg)
def delete_models(self):
"""Deleting selected model(s)."""
selection_model = self.models_tv.selectionModel()
if not selection_model.hasSelection():
return
try:
tc = ThreediCalls(self.threedi_api)
for index in selection_model.selectedRows():
current_row = index.row()
model_id_item = self.models_model.item(current_row, 0)
model_id = int(model_id_item.text())
tc.delete_3di_model(model_id)
except ApiException as e:
error_msg = extract_error_message(e)
self.communication.show_error(error_msg)
except Exception as e:
error_msg = f"Error: {e}"
self.communication.show_error(error_msg)
finally:
self.fetch_3di_models()
class ThinGreyscaleDialog(QDialog, FORM_CLASS):
def __init__(self, iface, parent=None):
"""Constructor."""
self.iface = iface
self.plugin_dir = dirname(__file__)
self.THINGREYSCALE = self.tr('ThinGreyscale')
self.BROWSE = self.tr('Browse')
self.CANCEL = self.tr('Cancel')
self.CLOSE = self.tr('Close')
self.HELP = self.tr('Help')
self.OK = self.tr('OK')
self.DEFAULTPROVIDER = 'GTiff'
self.DEFAULTEXTENSION = '.tif'
self.EXTRAEXTENSION = ' *.tiff'
super(ThinGreyscaleDialog, self).__init__(parent)
# Set up the user interface from Designer.
# After setupUI you can access any designer object by doing
# self.<objectname>, and you can use autoconnect slots - see
# http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html
# #widgets-and-dialogs-with-auto-connect
self.setupUi(self)
self.showInfo("Connecting UI components")
okButton = self.button_box.button(QDialogButtonBox.Ok)
okButton.setText(self.OK)
cancelButton = self.button_box.button(QDialogButtonBox.Cancel)
cancelButton.setText(self.CANCEL)
cancelButton.setEnabled(False)
closeButton = self.button_box.button(QDialogButtonBox.Close)
closeButton.setText(self.CLOSE)
browseButton = self.browseButton
browseButton.setText(self.BROWSE)
self.calcHistPushButton.setEnabled(False)
self.listModel = QStandardItemModel(self.levelsListView)
self.levelsListView.setModel(self.listModel)
self.levelsListView.sizeHintForColumn(20)
#self.levelValuesCheckBox.setEnabled(False)
# Help button
helpButton = self.helpButton
helpButton.setText(self.HELP)
# Connect signals
self.showInfo("Connecting signals")
okButton.clicked.connect(self.startWorker)
cancelButton.clicked.connect(self.killWorker)
closeButton.clicked.connect(self.reject)
helpButton.clicked.connect(self.help)
browseButton.clicked.connect(self.browse)
inpIndexCh = self.inputRaster.currentIndexChanged['QString']
inpIndexCh.connect(self.layerchanged)
bandCh = self.bandComboBox.currentIndexChanged['QString']
bandCh.connect(self.bandChanged)
#self.iface.legendInterface().itemAdded.connect(
# self.layerlistchanged)
#self.iface.legendInterface().itemRemoved.connect(
# self.layerlistchanged)
#QObject.disconnect(self.button_box, SIGNAL("rejected()"), self.reject)
self.button_box.rejected.disconnect(self.reject)
calchistPr = self.calcHistPushButton.clicked
calchistPr.connect(self.calculateHistogram)
sugglevPr = self.suggestlevelsPushButton.clicked
sugglevPr.connect(self.suggestLevels)
addlevPr = self.addlevelPushButton.clicked
addlevPr.connect(self.addLevel)
dellevPr = self.deletelevelsPushButton.clicked
dellevPr.connect(self.removeLevel)
maxvalCh = self.maxValueSpinBox.valueChanged
maxvalCh.connect(self.minmaxvalueChanged)
maxvalFi = self.maxValueSpinBox.editingFinished
maxvalFi.connect(self.minmaxvalueEdFinished)
minvalCh = self.minValueSpinBox.valueChanged
minvalCh.connect(self.minmaxvalueChanged)
minvalFi = self.minValueSpinBox.editingFinished
minvalFi.connect(self.minmaxvalueEdFinished)
# Set instance variables
#self.mem_layer = None
self.worker = None
self.inputlayerid = None
self.inputlayer = None
self.layerlistchanging = False
self.minvalue = 1
self.inputrasterprovider = None
self.histobins = 50
self.setupScene = QGraphicsScene(self)
self.histoGraphicsView.setScene(self.setupScene)
# Is the layer band of an integer type
self.intband = False
self.histogramAvailable = False
self.histo = None
self.histopadding = 1
def startWorker(self):
"""Initialises and starts the worker thread."""
try:
layerindex = self.inputRaster.currentIndex()
layerId = self.inputRaster.itemData(layerindex)
inputlayer = QgsProject.instance().mapLayer(layerId)
#inputlayer = QgsMapLayerRegistry.instance().mapLayer(layerId)
if inputlayer is None:
self.showError(self.tr('No input layer defined'))
return
# create a reference to the layer that is being processed
# (for use when creating the resulting raster layer)
self.thinninglayer = inputlayer
self.levels = []
#self.levelsListView.selectAll()
#selected = self.levelsListView.selectedIndexes()
if self.levelsListView.model().rowCount() == 0:
self.showInfo("Levels must be specified!")
return
for i in range(self.levelsListView.model().rowCount()):
levelstring = self.levelsListView.model().item(i).text()
#for i in selected:
# levelstring = self.levelsListView.model().itemData(i)[0]
if self.intband:
self.levels.append(int(levelstring))
else:
self.levels.append(float(levelstring))
#self.levelsListView.clearSelection()
# create a new worker instance
worker = Worker(inputlayer, self.levels, self.intband)
# configure the QgsMessageBar
msgBar = self.iface.messageBar().createMessage(
self.tr('Skeletonising'), '')
self.aprogressBar = QProgressBar()
self.aprogressBar.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
acancelButton = QPushButton()
acancelButton.setText(self.CANCEL)
acancelButton.clicked.connect(self.killWorker)
msgBar.layout().addWidget(self.aprogressBar)
msgBar.layout().addWidget(acancelButton)
# Has to be popped after the thread has finished (in
# workerFinished).
self.iface.messageBar().pushWidget(msgBar,
Qgis.Info)
self.messageBar = msgBar
# start the worker in a new thread
thread = QThread(self)
worker.moveToThread(thread)
worker.finished.connect(self.workerFinished)
worker.error.connect(self.workerError)
worker.status.connect(self.workerInfo)
worker.progress.connect(self.progressBar.setValue)
worker.progress.connect(self.aprogressBar.setValue)
worker.iterprogress.connect(self.iterProgressBar.setValue)
thread.started.connect(worker.run)
thread.start()
self.thread = thread
self.worker = worker
self.button_box.button(QDialogButtonBox.Ok).setEnabled(False)
self.button_box.button(QDialogButtonBox.Close).setEnabled(False)
self.button_box.button(QDialogButtonBox.Cancel).setEnabled(True)
except:
import traceback
self.showError(traceback.format_exc())
else:
pass
def workerFinished(self, ok, ret):
"""Handles the output from the worker and cleans up after the
worker has finished."""
# clean up the worker and thread
self.showInfo("Handling the result")
self.worker.deleteLater()
self.thread.quit()
self.thread.wait()
self.thread.deleteLater()
# remove widget from message bar (pop)
self.iface.messageBar().popWidget(self.messageBar)
if ok and ret is not None:
#self.showInfo("Ret: "+str(ret[10,]))
# Transformation:
self.minx = self.thinninglayer.extent().xMinimum()
self.maxx = self.thinninglayer.extent().xMaximum()
self.miny = self.thinninglayer.extent().yMinimum()
self.maxy = self.thinninglayer.extent().yMaximum()
self.rows = self.thinninglayer.height()
self.cols = self.thinninglayer.width()
self.xres = (self.maxx - self.minx) / float(self.cols)
self.yres = (self.maxy - self.miny) / float(self.rows)
geotransform = (self.minx, self.xres, 0, self.maxy, 0, -self.yres)
try:
format = self.DEFAULTPROVIDER
driver = gdal.GetDriverByName(format)
NOVALUE = 0
metadata = driver.GetMetadata()
fileName = self.outputRaster.text()
if self.outputRaster.text() == "":
self.showInfo("No output file specified, " +
"creating a temporary file")
# Get a temporary file
fileName = mktemp(prefix='greyskel',
suffix=self.DEFAULTEXTENSION)
fileInfo = QFileInfo(fileName)
filepath = fileInfo.absolutePath()
baseName = fileInfo.baseName()
suffix = fileInfo.suffix()
thisfilename = filepath + baseName + '.' + suffix
thisfilename = fileName
self.showInfo("File name: " + thisfilename)
gdaldatatype = gdal.GDT_Byte
skelmatrix = None
if self.levelValuesCheckBox.isChecked():
# Transform the pixel values back to the original
# level values
my_dict = {}
# Add zero to handle the "empty" pixels
my_dict[0] = 0
for i in range(len(self.levels)):
my_dict[i + 1] = self.levels[i]
skelmatrix = np.vectorize(my_dict.__getitem__,
otypes=[np.float])(ret)
gdaldatatype = gdal.GDT_Int32
if not self.intband:
gdaldatatype = gdal.GDT_Float32
else:
skelmatrix = ret
outDataset = driver.Create(thisfilename, self.cols,
self.rows, 1, gdaldatatype)
if self.thinninglayer.dataProvider().crs() is not None:
srs = self.thinninglayer.dataProvider().crs()
outDataset.SetProjection(srs.toWkt().encode('ascii',
'ignore'))
skeletonband = outDataset.GetRasterBand(1)
skeletonband.WriteArray(skelmatrix)
skeletonband.SetNoDataValue(NOVALUE)
#stats = skeletonband.GetStatistics(False, True)
#skeletonband.SetStatistics(stats[0], stats[1],
# stats[2], stats[3])
outDataset.SetGeoTransform(geotransform)
outDataset = None # To close the file
# report the result
rlayer = QgsRasterLayer(thisfilename, baseName)
self.layerlistchanging = True
#QgsMapLayerRegistry.instance().addMapLayer(rlayer)
QgsProject.instance().addMapLayer(rlayer)
self.layerlistchanging = False
except:
import traceback
self.showError("Can't write the skeleton file: %s" %
self.outputRaster.text() + ' - ' +
traceback.format_exc())
okb = self.button_box.button(QDialogButtonBox.Ok)
okb.setEnabled(True)
closb = self.button_box.button(QDialogButtonBox.Close)
closb.setEnabled(True)
cancb = self.button_box.button(QDialogButtonBox.Cancel)
cancb.setEnabled(False)
return
QgsMessageLog.logMessage(self.tr('ThinGreyscale finished'),
self.THINGREYSCALE, Qgis.Info)
else:
# notify the user that something went wrong
if not ok:
self.showError(self.tr('Aborted') + '!')
else:
self.showError(self.tr('No skeleton created') + '!')
self.progressBar.setValue(0.0)
#self.aprogressBar.setValue(0.0)
self.iterProgressBar.setValue(0.0)
self.button_box.button(QDialogButtonBox.Ok).setEnabled(True)
self.button_box.button(QDialogButtonBox.Close).setEnabled(True)
self.button_box.button(QDialogButtonBox.Cancel).setEnabled(False)
def workerError(self, exception_string):
"""Report an error from the worker."""
#QgsMessageLog.logMessage(self.tr('Worker failed - exception') +
# ': ' + str(exception_string),
# self.THINGREYSCALE,
# QgsMessageLog.CRITICAL)
self.showError(exception_string)
def workerInfo(self, message_string):
"""Report an info message from the worker."""
QgsMessageLog.logMessage(self.tr('Worker') + ': ' + message_string,
self.THINGREYSCALE, Qgis.Info)
def layerchanged(self, number=0):
"""Do the necessary updates after a layer selection has
been changed."""
self.showInfo("Layer changed")
# If the layer list is being updated, don't do anything
if self.layerlistchanging:
return
layerindex = self.inputRaster.currentIndex()
layerId = self.inputRaster.itemData(layerindex)
self.inputlayerid = layerId
#self.inputlayer = QgsMapLayerRegistry.instance().mapLayer(layerId)
self.inputlayer = QgsProject.instance().mapLayer(layerId)
if self.inputlayer is not None:
self.inputrasterprovider = self.inputlayer.dataProvider()
self.bandComboBox.clear()
bandcount = self.inputlayer.bandCount()
#self.showInfo("Layer bandcount: "+str(bandcount))
for i in range(bandcount):
self.bandComboBox.addItem(self.inputlayer.bandName(i + 1), i)
#self.showInfo("Band " + str(i) + ": " +
# self.inputlayer.bandName(i+1))
# Check if the driver supports Create() or CreateCopy()
#gdalmetadata = self.inputlayer.metadata()
#self.showInfo("Layer metadata: " +
# str(gdalmetadata.encode('utf-8')))
#provstring = '<p>GDAL provider</p>\n'
#providerpos = gdalmetadata.find(provstring)
#brpos = gdalmetadata.find('<br>', providerpos + len(provstring))
#self.gdalprovider = gdalmetadata[int(providerpos +
# len(provstring)):int(brpos)]
#self.showInfo('GDAL provider: '+self.gdalprovider)
#drivername = self.gdalprovider.encode('ascii', 'ignore')
#theDriver = gdal.GetDriverByName(drivername)
#if theDriver is None:
# self.showInfo("Unable to get the raster driver")
#else:
#data theMetadata = theDriver.GetMetadata()
#self.showInfo("Driver metadata: "+str(theMetadata))
#if ((gdal.DCAP_CREATE in theMetadata) and
# theMetadata[gdal.DCAP_CREATE] == 'YES'):
# self.canCreate = True
#if (theMetadata.has_key(gdal.DCAP_CREATECOPY) and
#if ((gdal.DCAP_CREATECOPY in theMetadata) and
# theMetadata[gdal.DCAP_CREATECOPY] == 'YES'):
# self.canCreateCopy = True
#self.showInfo('raster provider type: ' +
# str(self.inputlayer.providerType()))
# Determine the file suffix
#self.gdalext = ""
#if gdal.DMD_EXTENSION in theMetadata:
# self.gdalext = "." + theMetadata[gdal.DMD_EXTENSION]
#else:
# self.showInfo("No extension available in GDAL metadata")
# by parsing the layer metadata looking for
# "Dataset Description"
#descstring = 'Dataset Description</p>\n<p>'
#descpos = gdalmetadata.find(descstring)
#ppos = gdalmetadata.find('</p>',descpos+len(descstring))
#filename = gdalmetadata[descpos+len(descstring):ppos]
#self.gdalext = splitext(filename)[1]
#self.showInfo('GDAL extension: '+self.gdalext)
# Determine the datatype
#datatypestring = 'Data Type</p>\n<p>'
#datatypepos = gdalmetadata.find(datatypestring)
#ppos = gdalmetadata.find('</p>',
# datatypepos + len(datatypestring))
#datatypedesc = gdalmetadata[datatypepos +
# len(datatypestring):ppos]
#shortdesc = datatypedesc.split()[0]
#self.showInfo('GDAL data type: GDT_'+shortdesc)
# Call the findGdalDatatype function
#self.findGdalDatatype(shortdesc)
# self.button_box.button(QDialogButtonBox.Ok).setEnabled(True)
self.button_box.button(QDialogButtonBox.Ok).setEnabled(True)
self.calcHistPushButton.setEnabled(True)
self.suggestlevelsPushButton.setEnabled(True)
def bandChanged(self):
band = self.bandComboBox.currentIndex() + 1
self.showInfo("Band changed: " + str(band))
statistics = self.inputrasterprovider.bandStatistics(band)
#self.showInfo("Band statistics: " + str(statistics.minimumValue) +
# " - " + str(statistics.maximumValue) +
# " - " + str(statistics.mean))
self.bandmin = statistics.minimumValue
self.bandmax = statistics.maximumValue
dt = self.inputrasterprovider.dataType(band)
# Integer data type
if (dt == Qgis.Byte or dt == Qgis.UInt16 or dt == Qgis.Int16
or dt == Qgis.UInt32 or dt == Qgis.Int32):
self.intband = True
self.minValueSpinBox.setDecimals(0)
self.maxValueSpinBox.setDecimals(0)
self.levelSpinBox.setDecimals(0)
self.bandMinLabel.setText(str(int(statistics.minimumValue)))
self.bandMaxLabel.setText(str(int(statistics.maximumValue)))
else:
self.intband = False
self.minValueSpinBox.setDecimals(5)
self.maxValueSpinBox.setDecimals(5)
self.levelSpinBox.setDecimals(5)
minlabtext = "{0:.5f}".format(statistics.minimumValue)
self.bandMinLabel.setText(minlabtext)
maxlabtext = "{0:.5f}".format(statistics.maximumValue)
self.bandMaxLabel.setText(maxlabtext)
#self.minValueSpinBox.setMinimum(statistics.minimumValue)
self.maxValueSpinBox.setMinimum(statistics.minimumValue)
#self.minValueSpinBox.setMaximum(statistics.maximumValue)
self.maxValueSpinBox.setMaximum(statistics.maximumValue)
#self.minValueSpinBox.setValue(statistics.minimumValue)
if not (statistics.statsGathered & statistics.Mean):
bandmean = (statistics.minimumValue + statistics.maximumValue) / 2
else:
#self.showInfo("statsgathered: " + str(statistics.statsGathered))
bandmean = statistics.mean
if self.intband:
self.minValueSpinBox.setValue(int(ceil(bandmean)))
else:
self.minValueSpinBox.setValue(bandmean)
self.maxValueSpinBox.setValue(statistics.maximumValue)
self.histMinValue.setText(str(statistics.minimumValue))
self.histMaxValue.setText(str(statistics.maximumValue))
self.levelSpinBox.setMinimum(statistics.minimumValue)
self.levelSpinBox.setMaximum(statistics.maximumValue)
self.histogramAvailable = False
#if self.inputrasterprovider.hasStatistics(band):
#if statistics.statsGathered:
#histogram = statistics.histogramVector
#self.showInfo("Histogram: " + str(histogram))
#range = min to max
#np.histogram(band, 50, range)
def minmaxvalueChanged(self):
#if self.minValueSpinBox is None:
# return
minvalue = self.minValueSpinBox.value()
#if minvalue is None:
# return
#if self.maxValueSpinBox is None:
# return
maxvalue = self.maxValueSpinBox.value()
#if maxvalue is None:
# return
if isnan(maxvalue) or isnan(minvalue):
return
self.showInfo("minvalue: " + str(minvalue) + " Maxvalue: " +
str(maxvalue))
#if self.intband:
# minvalue = int(minvalue)
# maxvalue = int(maxvalue)
if abs(maxvalue - minvalue) < 0.00001:
#if maxvalue == maxvalue:
self.calcHistPushButton.setEnabled(False)
else:
self.calcHistPushButton.setEnabled(True)
# Update the min and max value spinboxes
self.minValueSpinBox.setMaximum(maxvalue)
self.maxValueSpinBox.setMinimum(minvalue)
self.minValueSpinBox.setMinimum(self.bandmin)
def minmaxvalueEdFinished(self):
minvalue = self.minValueSpinBox.value()
maxvalue = self.maxValueSpinBox.value()
if self.intband:
minvalue = int(minvalue)
maxvalue = int(maxvalue)
self.showInfo("minvalue: " + str(minvalue) + " Maxvalue: " +
str(maxvalue))
# Update the spin box for adding levels
self.levelSpinBox.setMinimum(minvalue)
self.levelSpinBox.setMaximum(maxvalue)
if self.levelSpinBox.value() < minvalue:
self.levelSpinBox.setValue(minvalue)
if self.levelSpinBox.value() > maxvalue:
self.levelSpinBox.setValue(maxvalue)
# Update the min and max value spinboxes
self.minValueSpinBox.setMaximum(maxvalue)
self.maxValueSpinBox.setMinimum(minvalue)
# Adjust the levels:
i = 0
while self.levelsListView.model().item(i):
#for i in range(self.levelsListView.model().rowCount()):
#self.showInfo("Element: " +
# str(self.levelsListView.model().item(i).text()))
#continue
value = float(self.levelsListView.model().item(i).text())
if value < minvalue:
if i == 0:
self.levelsListView.model().item(i).setText(str(minvalue))
i = i + 1
else:
self.levelsListView.model().removeRow(i)
elif value > maxvalue:
if i == self.levelsListView.model().rowCount() - 1:
self.levelsListView.model().item(i).setText(str(maxvalue))
i = i + 1
else:
self.levelsListView.model().removeRow(i)
else:
i = i + 1
self.drawHistogram()
def calculateHistogram(self):
self.showInfo("Calculating histogram...")
if self.inputlayer is None:
return
self.showInfo("Calculating histogram...")
# Check if there is only one value
myrange = (self.minValueSpinBox.value(),
self.maxValueSpinBox.value())
self.inputextent = self.inputlayer.extent()
self.inputrdp = self.inputlayer.dataProvider()
width = self.inputlayer.width()
height = self.inputlayer.height()
if width == 0 or height == 0:
self.showInfo("Image has zero width or height")
return
extwidth = self.inputextent.width()
extheight = self.inputextent.height()
# Read the raster block and get the maximum value
rasterblock = self.inputrdp.block(1, self.inputextent,
width, height)
# Create a numpy array version of the image
imageMat = np.zeros((height, width), dtype=np.float16)
# This one takes a lot of time!
for row in range(height):
for column in range(width):
imageMat[row, column] = rasterblock.value(row, column)
self.showInfo("Image: " + str(height) + ", " + str(width) + " - " + str(imageMat[row, column]))
self.histo = np.histogram(imageMat, self.histobins, myrange)
#relevantpixels = imageMat[np.where(imageMat >= bandval)]
minlevel = float(self.bandMinLabel.text())
relevantpixels = imageMat[np.where(imageMat >= minlevel)]
#self.showInfo("Histogram: " + str(self.histo))
nanpercentage = 100.0 - 100.0 * len(relevantpixels) / (width * height)
self.bandNANLabel.setText("{0:.1f}".format(nanpercentage))
#self.showInfo("Percentage NAN: " + str(100.0 - 100.0 *
# len(relevantpixels) / (width * height)))
#self.showInfo("First element: " + str(self.histo[0]))
#self.showInfo("First element, first: " + str(self.histo[0][0]))
#self.showInfo("First element, second: " + str(self.histo[0][1]))
self.histMinValue.setText(str(self.minValueSpinBox.value()))
self.histMaxValue.setText(str(self.maxValueSpinBox.value()))
if self.intband:
self.histMinValue.setText(str(int(self.minValueSpinBox.value())))
self.histMaxValue.setText(str(int(self.maxValueSpinBox.value())))
self.histogramAvailable = True
self.drawHistogram()
def drawHistogram(self):
#if self.inputlayer is None:
# return
self.showInfo("Drawing histogram...")
viewprect = QRectF(self.histoGraphicsView.viewport().rect())
self.histoGraphicsView.setSceneRect(viewprect)
self.setupScene.clear()
self.setupScene.update()
histbottom = self.histoGraphicsView.sceneRect().bottom()
histtop = self.histoGraphicsView.sceneRect().top()
left = self.histoGraphicsView.sceneRect().left() + self.histopadding
right = self.histoGraphicsView.sceneRect().right() - self.histopadding
histheight = histbottom - histtop
histwidth = right - left
step = 1.0 * histwidth / self.histobins
maxlength = histheight
padding = 1
ll = QPoint(self.histopadding - 1, histheight - padding)
start = QPointF(self.histoGraphicsView.mapToScene(ll))
# Check if there is only one value
#myrange = (self.minValueSpinBox.value(),self.maxValueSpinBox.value())
if self.histogramAvailable:
maxvalue = 0.0
for i in range(len(self.histo[0])):
if self.histo[0][i] > maxvalue:
maxvalue = self.histo[0][i]
if maxvalue == 0:
return
self.maxBinNumber.setText(str(maxvalue))
# Create the histogram:
#self.showInfo("maxvalue: " + str(maxvalue))
#self.showInfo("maxlength: " + str(maxlength))
#self.showInfo("step: " + str(step))
for i in range(self.histobins):
binnumber = self.histo[0][i]
if binnumber == 0:
continue
height = (1.0 * self.histo[0][i] / maxvalue *
(maxlength - padding))
rectangle = QGraphicsRectItem(start.x() + step * i,
start.y(),
step,
-height)
rectangle.setPen(QPen(QColor(102, 102, 102)))
rectangle.setBrush(QBrush(QColor(240, 240, 240)))
self.setupScene.addItem(rectangle)
#self.showInfo(str(i) + ": " + str(height))
#if self.levelsListView.model().rowCount() > 0:
# Add lines for the levels
minvalue = float(self.histMinValue.text())
maxvalue = float(self.histMaxValue.text())
datarange = maxvalue - minvalue
if datarange == 0:
return
i = 0
while self.levelsListView.model().item(i):
#self.showInfo("Element: " +
# str(self.levelsListView.model().item(i).text()))
#continue
value = float(self.levelsListView.model().item(i).text())
xvalue = start.x() + histwidth * (value - minvalue) / datarange
line = QGraphicsLineItem(xvalue, 0, xvalue, histheight)
if i == 0 or i == (self.levelsListView.model().rowCount() - 1):
line.setPen(QPen(QColor(204, 0, 0)))
else:
line.setPen(QPen(QColor(0, 204, 0)))
self.setupScene.addItem(line)
i = i + 1
def suggestLevels(self):
self.listModel.clear()
self.showInfo("Suggesting levels")
levels = self.levelsSpinBox.value()
startvalue = self.minValueSpinBox.value()
endvalue = self.maxValueSpinBox.value()
increment = (endvalue - startvalue) / levels
for i in range(levels + 1):
value = startvalue + increment * i
if self.intband:
value = int(value)
item = QStandardItem(str(value))
self.listModel.appendRow(item)
self.drawHistogram()
def addLevel(self):
newvalue = self.levelSpinBox.value()
if self.intband:
newvalue = int(newvalue)
for i in range(self.listModel.rowCount()):
# Check if the value is already in the list
if self.listModel.item(i).text() == str(newvalue):
return
else:
# Maintain a sorted list of distances
if (float(self.listModel.item(i).text()) >
float(str(newvalue))):
item = QStandardItem(str(newvalue))
self.listModel.insertRow(i, item)
self.drawHistogram()
return
item = QStandardItem(str(newvalue))
self.listModel.appendRow(item)
#if self.histogramAvailable:
# addLevelsToHistogram()
self.drawHistogram()
def removeLevel(self):
self.levelsListView.setUpdatesEnabled(False)
indexes = self.levelsListView.selectedIndexes()
indexes.sort()
for i in range(len(indexes) - 1, -1, -1):
self.listModel.removeRow(indexes[i].row())
self.levelsListView.setUpdatesEnabled(True)
#if self.histogramAvailable:
# removeLevelFromHistogram()
self.drawHistogram()
def layerlistchanged(self):
self.layerlistchanging = True
self.showInfo("Layer list changed")
# Repopulate the input layer combo box
# Save the currently selected input layer
inputlayerid = self.inputlayerid
self.inputRaster.clear()
for alayer in self.iface.legendInterface().layers():
if alayer.type() == QgsMapLayer.RasterLayer:
gdalmetadata = alayer.metadata()
# Skip WMS layers
WMSstring = 'Web Map Service'
wmspos = gdalmetadata.find(WMSstring)
if wmspos != -1:
continue
self.inputRaster.addItem(alayer.name(), alayer.id())
# Set the previous selection
for i in range(self.inputRaster.count()):
if self.inputRaster.itemData(i) == inputlayerid:
self.inputRaster.setCurrentIndex(i)
self.layerlistchanging = False
#self.updateui()
def updateui(self):
"""Do the necessary updates after a layer selection has
been changed."""
#if self.layerlistchanged:
# return
#self.outputRaster.setText(self.inputRaster.currentText() +
# '_' + 'thinned')
layerindex = self.inputRaster.currentIndex()
layerId = self.inputRaster.itemData(layerindex)
#inputlayer = QgsMapLayerRegistry.instance().mapLayer(layerId)
inputlayer = QgsProject.instance().mapLayer(layerId)
if inputlayer is not None:
pass
else:
pass
def findGdalDatatype(self, shortdesc):
gdaldatatype = None
# // Unknown or unspecified type
# GDT_Unknown = GDALDataType(C.GDT_Unknown)
if shortdesc == 'Unknown':
gdaldatatype = gdal.GDT_Unknown
# // Eight bit unsigned integer
# GDT_Byte = GDALDataType(C.GDT_Byte)
elif shortdesc == 'Byte':
gdaldatatype = gdal.GDT_Byte
# // Sixteen bit unsigned integer
# GDT_UInt16 = GDALDataType(C.GDT_UInt16)
elif shortdesc == 'UInt16':
gdaldatatype = gdal.GDT_UInt16
# // Sixteen bit signed integer
# GDT_Int16 = GDALDataType(C.GDT_Int16)
elif shortdesc == 'Int16':
gdaldatatype = gdal.GDT_Int16
# // Thirty two bit unsigned integer
# GDT_UInt32 = GDALDataType(C.GDT_UInt32)
elif shortdesc == 'UInt32':
gdaldatatype = gdal.GDT_UInt32
# // Thirty two bit signed integer
# GDT_Int32 = GDALDataType(C.GDT_Int32)
elif shortdesc == 'Int32':
gdaldatatype = gdal.GDT_Int32
# // Thirty two bit floating point
# GDT_Float32 = GDALDataType(C.GDT_Float32)
elif shortdesc == 'Float32':
gdaldatatype = gdal.GDT_Float32
# // Sixty four bit floating point
# GDT_Float64 = GDALDataType(C.GDT_Float64)
elif shortdesc == 'Float64':
gdaldatatype = gdal.GDT_Float64
# // Complex Int16
# GDT_CInt16 = GDALDataType(C.GDT_CInt16)
elif shortdesc == 'CInt16':
gdaldatatype = gdal.CInt16
# // Complex Int32
# GDT_CInt32 = GDALDataType(C.GDT_CInt32)
elif shortdesc == 'CInt32':
gdaldatatype = gdal.CInt32
# // Complex Float32
# GDT_CFloat32 = GDALDataType(C.GDT_CFloat32)
elif shortdesc == 'CFloat32':
gdaldatatype = gdal.CFloat32
# // Complex Float64
# GDT_CFloat64 = GDALDataType(C.GDT_CFloat64)
elif shortdesc == 'CFloat64':
gdaldatatype = gdal.CFloat64
# // maximum type # + 1
# GDT_TypeCount = GDALDataType(C.GDT_TypeCount)
elif shortdesc == 'TypeCount':
gdaldatatype = gdal.TypeCount
self.gdaldatatype = gdaldatatype
def killWorker(self):
"""Kill the worker thread."""
if self.worker is not None:
QgsMessageLog.logMessage(self.tr('Killing worker'),
self.THINGREYSCALE, Qgis.Info)
self.worker.kill()
def showError(self, text):
"""Show an error."""
self.iface.messageBar().pushMessage(self.tr('Error'), text,
level=QgsMessageBar.CRITICAL,
duration=3)
QgsMessageLog.logMessage('Error: ' + text, self.THINGREYSCALE,
QgsMessageLog.CRITICAL)
def showWarning(self, text):
"""Show a warning."""
self.iface.messageBar().pushMessage(self.tr('Warning'), text,
level=QgsMessageBar.WARNING,
duration=2)
QgsMessageLog.logMessage('Warning: ' + text, self.THINGREYSCALE,
QgsMessageLog.WARNING)
def showInfo(self, text):
"""Show info."""
self.iface.messageBar().pushMessage(self.tr('Info'), text,
level=Qgis.Info,
duration=2)
QgsMessageLog.logMessage('Info: ' + text, self.THINGREYSCALE,
Qgis.Info)
# def help(self):
# #QDesktopServices.openUrl(QUrl.fromLocalFile(self.plugin_dir +
# "/help/build/html/index.html"))
# QDesktopServices.openUrl(QUrl.fromLocalFile(self.plugin_dir +
# "/help/index.html"))
# #showPluginHelp()
def tr(self, message):
"""Get the translation for a string using Qt translation API.
:param message: String for translation.
:type message: str, QString
:returns: Translated version of message.
:rtype: QString
"""
return QCoreApplication.translate('ThinGreyScaleDialog', message)
def browse(self):
settings = QSettings()
key = '/UI/lastShapefileDir'
outDir = settings.value(key)
home = outDir
#outDir = expanduser("~")
#filter = (self.DEFAULTPROVIDER + " (*" +
# self.DEFAULTEXTENSION + ");;All files (*)")
filter = (self.DEFAULTPROVIDER + " (*" +
self.DEFAULTEXTENSION + self.EXTRAEXTENSION + ")")
#if (self.gdalprovider != self.DEFAULTPROVIDER and
# (self.canCreateCopy or
# self.canCreate)):
# filter = (self.gdalprovider + " (*" + self.gdalext +
# ");;" + filter)
outFilePath = QFileDialog.getSaveFileName(self,
'Specify file name for skeleton',
outDir, filter)
outFilePath = unicode(outFilePath)
if outFilePath:
root, ext = splitext(outFilePath)
if ext.lower() != '.tif' and ext.lower() != '.tiff':
outFilePath = '%s.tif' % outFilePath
outDir = dirname(outFilePath)
settings.setValue(key, outDir)
# (self.canCreateCopy or self.canCreate):
# fileName = splitext(str(fileName))[0]+self.gdalext
self.outputRaster.setText(outFilePath)
# Overriding
def resizeEvent(self, event):
#self.showInfo("resizeEvent")
self.calculateHistogram()
def help(self):
#QDesktopServices.openUrl(QUrl.fromLocalFile(
# self.plugin_dir + "/help/html/index.html"))
showPluginHelp(None, "help/html/index")
# Implement the accept method to avoid exiting the dialog when
# starting the work
def accept(self):
"""Accept override."""
pass
# Implement the reject method to have the possibility to avoid
# exiting the dialog when cancelling
def reject(self):
"""Reject override."""
# exit the dialog
QDialog.reject(self)
class FKProperty(WIDGET, BASE):
"""
Editor to create/edit ForeignKey column property
"""
def __init__(self, parent, relation={}):
"""
:param parent: Owner of the form
:type parent: QWidget
:param relation: Dictionary holding fields used to build foreign key column
*entity_relation - EntityRelation object, if its None then
this is a new column else its an edit
*fk_entities - entities used for ForeignKey selection
*profile - current profile
*entity - current entity you are creating column for.
*column_name - name of the column
:type form_field: dictionary
"""
QDialog.__init__(self, parent)
self.setupUi(self)
self._entity_relation = relation['form_fields']['entity_relation']
self.fk_entities = relation['fk_entities']
self.profile = relation['profile']
self.entity = relation['entity']
self.column_name = relation['column_name']
self.in_db = relation['form_fields']['in_db']
self._show_in_parent = relation['show_in_parent']
self._show_in_child = relation['show_in_child']
self.column_model = QStandardItemModel()
self.lvDisplayCol.setModel(self.column_model)
self.init_gui()
def init_gui(self):
"""
Initializes form fields
"""
self.cboPrimaryEntity.currentIndexChanged.connect( \
self.load_entity_columns)
self.load_fk_entities()
if self._entity_relation:
parent = self._entity_relation.parent.short_name
parent_column = self._entity_relation.parent_column
display_cols = self._entity_relation.display_cols
self.cboPrimaryEntity.setCurrentIndex( \
self.cboPrimaryEntity.findText(parent))
self.cboPrimaryUKey.setCurrentIndex( \
self.cboPrimaryUKey.findText(parent_column))
self.show_display_cols(display_cols)
# Disable controls if column exists in the database
self.cboPrimaryEntity.setEnabled(not self.in_db)
self.cboPrimaryUKey.setEnabled(not self.in_db)
self.lvDisplayCol.setEnabled(not self.in_db)
self.show_in_parent_chk.clicked.connect(self.on_show_in_parent_clicked)
self.show_in_child_chk.clicked.connect(self.on_show_in_child_clicked)
def on_show_in_parent_clicked(self):
"""
A slot raised when show in parent is clicked.
:return:
:rtype:
"""
if self.show_in_parent_chk.isChecked():
self.show_in_child_chk.setChecked(False)
self._show_in_parent = True
def on_show_in_child_clicked(self):
"""
A slot raised when show in child is clicked.
:return:
:rtype:
"""
if self.show_in_child_chk.isChecked():
self.show_in_parent_chk.setChecked(False)
self._show_in_child = True
def show_in_parent(self):
"""
Returns show in parent.
:return: Returns show in parent.
:rtype: Boolean
"""
return self._show_in_parent
def show_in_child(self):
"""
Returns show in child.
:return: Returns show in child.
:rtype: Boolean
"""
return self._show_in_child
def show_display_cols(self, display_cols):
"""
checks previously selected display columns
"""
for row in range(self.column_model.rowCount()):
if str(self.column_model.item(row).text()) in display_cols:
self.column_model.item(row).setCheckState(Qt.Checked)
def load_fk_entities(self):
"""
populates combobox with entities to select primary entity for the
foreign key
"""
self.cboPrimaryEntity.clear()
self.cboPrimaryEntity.insertItems(
0, [name[0] for name in self.fk_entities])
self.cboPrimaryEntity.setCurrentIndex(0)
def entity_columns(self):
"""
returns: A list used to select child entity column when building
a foreign key
rtype: list
"""
index = self.cboPrimaryEntity.currentIndex()
entity_columns = \
[column for column in self.fk_entities[index][1].columns.items()]
column_names = [column[0] for column in entity_columns]
return column_names
def fk_display_columns(self):
"""
returns: A list of columns used to select display columns
in foreign key
rtype: list
"""
index = self.cboPrimaryEntity.currentIndex()
entity_columns = \
[column for column in self.fk_entities[index][1].columns.items()]
columns = [column[0] for column in entity_columns \
if column[1].TYPE_INFO != 'SERIAL']
return columns
def load_entity_columns(self):
"""
"""
columns = self.entity_columns()
self.populate_column_combobox(columns)
disp_columns = self.fk_display_columns()
self.populate_column_listview(disp_columns)
def populate_column_combobox(self, columns):
"""
Populate combobox with column names
param columns: List of entity columns to select your primary unique
column for the foreign key
type columns: list
"""
self.cboPrimaryUKey.clear()
self.cboPrimaryUKey.insertItems(0, columns)
def populate_column_listview(self, columns):
"""
Populates list view with columns used in selecting
display columns for foreign key
param columns: A list of column names
type columns: list
"""
self.column_model.clear()
for column in columns:
item = QStandardItem(column)
item.setCheckable(True)
self.column_model.appendRow(item)
def add_values(self):
"""
Construct an EntityRelation instance from form fields
"""
er_fields = {}
er_fields['parent'] = str(self.cboPrimaryEntity.currentText())
er_fields['parent_column'] = str(self.cboPrimaryUKey.currentText())
er_fields['display_columns'] = self.display_columns()
er_fields['child'] = self.entity
er_fields['child_column'] = self.column_name
self._entity_relation = EntityRelation(self.profile, **er_fields)
def display_columns(self):
"""
Scans StandardItemModel for display columns, and returns a list of
selected/checked columns for display in foreign key
rtype: list
"""
return [str(self.column_model.item(row).text()) \
for row in range(self.column_model.rowCount()) \
if self.column_model.item(row).checkState() == Qt.Checked]
def entity_relation(self):
"""
returns: entity relation instance
rtype: EntityRelation
"""
return self._entity_relation
def accept(self):
self.add_values()
self.done(1)
def reject(self):
self.done(0)
class ModelSelectionDialog(uicls, basecls):
"""Dialog for model selection."""
TABLE_LIMIT = 10
NAME_COLUMN_IDX = 1
def __init__(self, plugin_dock, parent=None):
super().__init__(parent)
self.setupUi(self)
self.plugin_dock = plugin_dock
self.communication = self.plugin_dock.communication
self.current_user = self.plugin_dock.current_user
self.threedi_api = self.plugin_dock.threedi_api
self.organisations = self.plugin_dock.organisations
self.threedi_models = None
self.simulation_templates = None
self.current_model = None
self.current_model_cells = None
self.current_model_breaches = None
self.current_simulation_template = None
self.cells_layer = None
self.breaches_layer = None
self.organisation = None
self.model_is_loaded = False
self.models_model = QStandardItemModel()
self.models_tv.setModel(self.models_model)
self.templates_model = QStandardItemModel()
self.templates_tv.setModel(self.templates_model)
self.pb_prev_page.clicked.connect(self.move_models_backward)
self.pb_next_page.clicked.connect(self.move_models_forward)
self.page_sbox.valueChanged.connect(self.fetch_3di_models)
self.pb_load.clicked.connect(self.load_model)
self.pb_cancel_load.clicked.connect(self.cancel_load_model)
self.search_le.returnPressed.connect(self.search_model)
self.models_tv.selectionModel().selectionChanged.connect(
self.refresh_templates_list)
self.templates_tv.selectionModel().selectionChanged.connect(
self.toggle_load_model)
self.populate_organisations()
self.fetch_3di_models()
def refresh_templates_list(self):
"""Refresh simulation templates list if any model is selected."""
selection_model = self.models_tv.selectionModel()
self.templates_model.clear()
self.templates_page_sbox.setMaximum(1)
self.templates_page_sbox.setSuffix(" / 1")
if selection_model.hasSelection():
self.fetch_simulation_templates()
if self.templates_model.rowCount() > 0:
row_idx = self.templates_model.index(0, 0)
self.templates_tv.selectionModel().setCurrentIndex(
row_idx, QItemSelectionModel.ClearAndSelect)
self.toggle_load_model()
def toggle_load_model(self):
"""Toggle load button if any model is selected."""
selection_model = self.templates_tv.selectionModel()
if selection_model.hasSelection():
self.pb_load.setEnabled(True)
else:
self.pb_load.setDisabled(True)
def move_models_backward(self):
"""Moving to the models previous results page."""
self.page_sbox.setValue(self.page_sbox.value() - 1)
def move_models_forward(self):
"""Moving to the models next results page."""
self.page_sbox.setValue(self.page_sbox.value() + 1)
def move_templates_backward(self):
"""Moving to the templates previous results page."""
self.templates_page_sbox.setValue(self.page_sbox.value() - 1)
def move_templates_forward(self):
"""Moving to the templates next results page."""
self.templates_page_sbox.setValue(self.page_sbox.value() + 1)
def populate_organisations(self):
"""Populating organisations list inside combo box."""
for org in self.organisations.values():
self.organisations_box.addItem(org.name, org)
def fetch_3di_models(self):
"""Fetching 3Di models list."""
try:
tc = ThreediCalls(self.threedi_api)
offset = (self.page_sbox.value() - 1) * self.TABLE_LIMIT
text = self.search_le.text()
threedi_models, models_count = tc.fetch_3di_models_with_count(
limit=self.TABLE_LIMIT, offset=offset, name_contains=text)
pages_nr = ceil(models_count / self.TABLE_LIMIT) or 1
self.page_sbox.setMaximum(pages_nr)
self.page_sbox.setSuffix(f" / {pages_nr}")
self.models_model.clear()
header = [
"ID", "Model", "Schematisation", "Revision", "Last updated",
"Updated by"
]
self.models_model.setHorizontalHeaderLabels(header)
for sim_model in sorted(threedi_models,
key=attrgetter("revision_commit_date"),
reverse=True):
id_item = QStandardItem(str(sim_model.id))
name_item = QStandardItem(sim_model.name)
name_item.setData(sim_model, role=Qt.UserRole)
schema_item = QStandardItem(sim_model.schematisation_name)
rev_item = QStandardItem(sim_model.revision_number)
last_updated_day = sim_model.revision_commit_date.split("T")[0]
lu_datetime = QDateTime.fromString(last_updated_day,
"yyyy-MM-dd")
lu_item = QStandardItem(lu_datetime.toString("dd-MMMM-yyyy"))
ub_item = QStandardItem(sim_model.user)
self.models_model.appendRow([
id_item, name_item, schema_item, rev_item, lu_item, ub_item
])
self.threedi_models = threedi_models
except ApiException as e:
self.close()
error_msg = extract_error_message(e)
self.communication.show_error(error_msg)
except Exception as e:
self.close()
error_msg = f"Error: {e}"
self.communication.show_error(error_msg)
def fetch_simulation_templates(self):
"""Fetching simulation templates list."""
try:
tc = ThreediCalls(self.threedi_api)
offset = (self.templates_page_sbox.value() - 1) * self.TABLE_LIMIT
selected_model = self.get_selected_model()
model_pk = selected_model.id
templates, templates_count = tc.fetch_simulation_templates_with_count(
model_pk, limit=self.TABLE_LIMIT, offset=offset)
pages_nr = ceil(templates_count / self.TABLE_LIMIT) or 1
self.templates_page_sbox.setMaximum(pages_nr)
self.templates_page_sbox.setSuffix(f" / {pages_nr}")
self.templates_model.clear()
header = ["Template ID", "Template name", "Creation date"]
self.templates_model.setHorizontalHeaderLabels(header)
for template in sorted(templates,
key=attrgetter("id"),
reverse=True):
id_item = QStandardItem(str(template.id))
name_item = QStandardItem(template.name)
name_item.setData(template, role=Qt.UserRole)
creation_date = template.created.strftime(
"%d-%m-%Y") if template.created else ""
creation_date_item = QStandardItem(creation_date)
self.templates_model.appendRow(
[id_item, name_item, creation_date_item])
for i in range(len(header)):
self.templates_tv.resizeColumnToContents(i)
self.simulation_templates = templates
except ApiException as e:
error_msg = extract_error_message(e)
self.communication.show_error(error_msg)
except Exception as e:
error_msg = f"Error: {e}"
self.communication.show_error(error_msg)
def search_model(self):
"""Method used for searching models with text typed withing search bar."""
self.page_sbox.valueChanged.disconnect(self.fetch_3di_models)
self.page_sbox.setValue(1)
self.page_sbox.valueChanged.connect(self.fetch_3di_models)
self.fetch_3di_models()
def load_cached_layers(self):
"""Loading cached layers into the map canvas."""
if self.current_model_cells is not None:
self.cells_layer = QgsVectorLayer(self.current_model_cells,
"cells", "ogr")
set_named_style(self.cells_layer, "cells.qml")
QgsProject.instance().addMapLayer(self.cells_layer, False)
QgsProject.instance().layerTreeRoot().insertLayer(
0, self.cells_layer)
self.cells_layer.setFlags(QgsMapLayer.Searchable
| QgsMapLayer.Identifiable)
if self.current_model_breaches is not None:
self.breaches_layer = QgsVectorLayer(self.current_model_breaches,
"breaches", "ogr")
set_named_style(self.breaches_layer, "breaches.qml")
QgsProject.instance().addMapLayer(self.breaches_layer, False)
QgsProject.instance().layerTreeRoot().insertLayer(
0, self.breaches_layer)
self.breaches_layer.setFlags(QgsMapLayer.Searchable
| QgsMapLayer.Identifiable)
if self.current_model_cells is not None:
self.plugin_dock.iface.setActiveLayer(self.cells_layer)
self.plugin_dock.iface.zoomToActiveLayer()
def unload_cached_layers(self):
"""Removing model related vector layers from map canvas."""
try:
if self.breaches_layer is not None:
QgsProject.instance().removeMapLayer(self.breaches_layer)
self.breaches_layer = None
if self.cells_layer is not None:
QgsProject.instance().removeMapLayer(self.cells_layer)
self.cells_layer = None
self.plugin_dock.iface.mapCanvas().refresh()
except AttributeError:
pass
def load_model(self):
"""Loading selected model."""
index = self.models_tv.currentIndex()
if index.isValid():
self.organisation = self.organisations_box.currentData()
self.unload_cached_layers()
current_row = index.row()
name_item = self.models_model.item(current_row,
self.NAME_COLUMN_IDX)
self.current_model = name_item.data(Qt.UserRole)
self.current_model_cells = self.get_cached_data("cells")
self.current_model_breaches = self.get_cached_data("breaches")
self.current_simulation_template = self.get_selected_template()
self.load_cached_layers()
self.model_is_loaded = True
self.close()
def cancel_load_model(self):
"""Cancel loading model."""
self.current_simulation_template = None
self.model_is_loaded = False
self.close()
def get_selected_model(self):
"""Get currently selected model."""
index = self.models_tv.currentIndex()
if index.isValid():
current_row = index.row()
name_item = self.models_model.item(current_row,
self.NAME_COLUMN_IDX)
selected_model = name_item.data(Qt.UserRole)
else:
selected_model = None
return selected_model
def get_selected_template(self):
"""Get currently selected simulation template."""
index = self.templates_tv.currentIndex()
if index.isValid():
current_row = index.row()
name_item = self.templates_model.item(current_row,
self.NAME_COLUMN_IDX)
selected_template = name_item.data(Qt.UserRole)
else:
selected_template = None
return selected_template
def get_cached_data(self, geojson_name):
"""Get model data that should be cached."""
cached_file_path = None
try:
tc = ThreediCalls(self.threedi_api)
model_id = self.current_model.id
if geojson_name == "breaches":
download = tc.fetch_3di_model_geojson_breaches_download(
model_id)
elif geojson_name == "cells":
download = tc.fetch_3di_model_geojson_cells_download(model_id)
else:
return cached_file_path
filename = f"{geojson_name}_{model_id}_{download.etag}.json"
file_path = os.path.join(CACHE_PATH, filename)
if not file_cached(file_path):
get_download_file(download, file_path)
cached_file_path = file_path
self.communication.bar_info(f"Model {geojson_name} cached.")
except ApiException as e:
error_msg = extract_error_message(e)
if "geojson file not found" in error_msg:
pass
else:
self.communication.bar_error(error_msg)
except Exception as e:
logger.exception("Error when getting to-be-cached data")
error_msg = f"Error: {e}"
self.communication.bar_error(error_msg)
return cached_file_path
class ModelAtrributesView(QListView):
"""
Custom QListView implementation that displays checkable model attributes.
"""
def __init__(self, parent=None, dataModel=None):
QListView.__init__(self, parent)
self._dataModel = dataModel
self._selectedDisplayMapping = OrderedDict()
self._modelDisplayMapping = OrderedDict()
self._attrModel = QStandardItemModel(self)
def dataModel(self):
"""
Returns the data model instance.
"""
return self._dataModel
def setDataModel(self, dataModel):
"""
Sets the data model. Should be a callable class rather than the class.
instance.
"""
if callable(dataModel):
self._dataModel = dataModel
else:
self._dataModel = dataModel.__class__
def modelDisplayMapping(self):
"""
Returns the column name and display name collection.
"""
return self._modelDisplayMapping
def setModelDisplayMapping(self, dataMapping):
"""
Sets the mapping dictionary for the table object
"""
if dataMapping != None:
self._modelDisplayMapping = dataMapping
def load(self, sort=False):
"""
Load the model's attributes into the list view.
"""
if self._dataModel == None:
return
try:
self._loadAttrs(self._dataModel.displayMapping(), sort)
except AttributeError:
# Ignore error if model does not contain
# the displayMapping static method
pass
def load_mapping(self, mapping, sort=False):
"""
Load collection containing column name and corresponding display name.
"""
self._modelDisplayMapping = mapping
self._loadAttrs(mapping, sort)
def sort(self):
"""
Sorts display name in ascending order.
"""
self._attrModel.sort(0)
def _loadAttrs(self, attrMapping, sort=False):
"""
Loads display mapping into the list view.
Specify to sort display names in ascending order once items have been
added to the model.
"""
self._attrModel.clear()
self._attrModel.setColumnCount(2)
for attrName, displayName in attrMapping.items():
# Exclude row ID in the list, other unique identifier attributes in the model can be used
if attrName != "id":
displayNameItem = QStandardItem(displayName)
displayNameItem.setCheckable(True)
attrNameItem = QStandardItem(attrName)
self._attrModel.appendRow([displayNameItem, attrNameItem])
self.setModel(self._attrModel)
if sort:
self._attrModel.sort(0)
def selectedMappings(self):
"""
Return a dictionary of field names and their corresponding display values.
"""
selectedAttrs = OrderedDict()
for i in range(self._attrModel.rowCount()):
displayNameItem = self._attrModel.item(i, 0)
if displayNameItem.checkState() == Qt.Checked:
attrNameItem = self._attrModel.item(i, 1)
selectedAttrs[attrNameItem.text()] = displayNameItem.text()
return selectedAttrs
class DlgSqlWindow(QWidget, Ui_Dialog):
nameChanged = pyqtSignal(str)
def __init__(self, iface, db, parent=None):
QWidget.__init__(self, parent)
self.iface = iface
self.db = db
self.filter = ""
self.allowMultiColumnPk = isinstance(db, PGDatabase) # at the moment only PostgreSQL allows a primary key to span multiple columns, SpatiaLite doesn't
self.aliasSubQuery = isinstance(db, PGDatabase) # only PostgreSQL requires subqueries to be aliases
self.setupUi(self)
self.setWindowTitle(
self.tr(u"{0} - {1} [{2}]").format(self.windowTitle(), db.connection().connectionName(), db.connection().typeNameString()))
self.defaultLayerName = 'QueryLayer'
if self.allowMultiColumnPk:
self.uniqueColumnCheck.setText(self.tr("Column(s) with unique values"))
else:
self.uniqueColumnCheck.setText(self.tr("Column with unique values"))
self.editSql.setFocus()
self.editSql.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.editSql.setMarginVisible(True)
self.initCompleter()
# allow copying results
copyAction = QAction("copy", self)
self.viewResult.addAction(copyAction)
copyAction.setShortcuts(QKeySequence.Copy)
copyAction.triggered.connect(self.copySelectedResults)
self.btnExecute.clicked.connect(self.executeSql)
self.btnSetFilter.clicked.connect(self.setFilter)
self.btnClear.clicked.connect(self.clearSql)
self.presetStore.clicked.connect(self.storePreset)
self.presetDelete.clicked.connect(self.deletePreset)
self.presetCombo.activated[str].connect(self.loadPreset)
self.presetCombo.activated[str].connect(self.presetName.setText)
self.updatePresetsCombobox()
self.geomCombo.setEditable(True)
self.geomCombo.lineEdit().setReadOnly(True)
self.uniqueCombo.setEditable(True)
self.uniqueCombo.lineEdit().setReadOnly(True)
self.uniqueModel = QStandardItemModel(self.uniqueCombo)
self.uniqueCombo.setModel(self.uniqueModel)
if self.allowMultiColumnPk:
self.uniqueCombo.setItemDelegate(QStyledItemDelegate())
self.uniqueModel.itemChanged.connect(self.uniqueChanged) # react to the (un)checking of an item
self.uniqueCombo.lineEdit().textChanged.connect(self.uniqueTextChanged) # there are other events that change the displayed text and some of them can not be caught directly
# hide the load query as layer if feature is not supported
self._loadAsLayerAvailable = self.db.connector.hasCustomQuerySupport()
self.loadAsLayerGroup.setVisible(self._loadAsLayerAvailable)
if self._loadAsLayerAvailable:
self.layerTypeWidget.hide() # show if load as raster is supported
self.loadLayerBtn.clicked.connect(self.loadSqlLayer)
self.getColumnsBtn.clicked.connect(self.fillColumnCombos)
self.loadAsLayerGroup.toggled.connect(self.loadAsLayerToggled)
self.loadAsLayerToggled(False)
self._createViewAvailable = self.db.connector.hasCreateSpatialViewSupport()
self.btnCreateView.setVisible(self._createViewAvailable)
if self._createViewAvailable:
self.btnCreateView.clicked.connect(self.createView)
self.queryBuilderFirst = True
self.queryBuilderBtn.setIcon(QIcon(":/db_manager/icons/sql.gif"))
self.queryBuilderBtn.clicked.connect(self.displayQueryBuilder)
self.presetName.textChanged.connect(self.nameChanged)
def updatePresetsCombobox(self):
self.presetCombo.clear()
names = []
entries = QgsProject.instance().subkeyList('DBManager', 'savedQueries')
for entry in entries:
name = QgsProject.instance().readEntry('DBManager', 'savedQueries/' + entry + '/name')[0]
names.append(name)
for name in sorted(names):
self.presetCombo.addItem(name)
self.presetCombo.setCurrentIndex(-1)
def storePreset(self):
query = self._getSqlQuery()
if query == "":
return
name = self.presetName.text()
QgsProject.instance().writeEntry('DBManager', 'savedQueries/q' + str(name.__hash__()) + '/name', name)
QgsProject.instance().writeEntry('DBManager', 'savedQueries/q' + str(name.__hash__()) + '/query', query)
index = self.presetCombo.findText(name)
if index == -1:
self.presetCombo.addItem(name)
self.presetCombo.setCurrentIndex(self.presetCombo.count() - 1)
else:
self.presetCombo.setCurrentIndex(index)
def deletePreset(self):
name = self.presetCombo.currentText()
QgsProject.instance().removeEntry('DBManager', 'savedQueries/q' + str(name.__hash__()))
self.presetCombo.removeItem(self.presetCombo.findText(name))
self.presetCombo.setCurrentIndex(-1)
def loadPreset(self, name):
query = QgsProject.instance().readEntry('DBManager', 'savedQueries/q' + str(name.__hash__()) + '/query')[0]
name = QgsProject.instance().readEntry('DBManager', 'savedQueries/q' + str(name.__hash__()) + '/name')[0]
self.editSql.setText(query)
def loadAsLayerToggled(self, checked):
self.loadAsLayerGroup.setChecked(checked)
self.loadAsLayerWidget.setVisible(checked)
if checked:
self.fillColumnCombos()
def clearSql(self):
self.editSql.clear()
self.editSql.setFocus()
self.filter = ""
def executeSql(self):
sql = self._getSqlQuery()
if sql == "":
return
with OverrideCursor(Qt.WaitCursor):
# delete the old model
old_model = self.viewResult.model()
self.viewResult.setModel(None)
if old_model:
old_model.deleteLater()
cols = []
quotedCols = []
try:
# set the new model
model = self.db.sqlResultModel(sql, self)
self.viewResult.setModel(model)
self.lblResult.setText(self.tr("{0} rows, {1:.1f} seconds").format(model.affectedRows(), model.secs()))
cols = self.viewResult.model().columnNames()
for col in cols:
quotedCols.append(self.db.connector.quoteId(col))
except BaseError as e:
DlgDbError.showError(e, self)
self.uniqueModel.clear()
self.geomCombo.clear()
return
self.setColumnCombos(cols, quotedCols)
self.update()
def _getSqlLayer(self, _filter):
hasUniqueField = self.uniqueColumnCheck.checkState() == Qt.Checked
if hasUniqueField:
if self.allowMultiColumnPk:
checkedCols = []
for item in self.uniqueModel.findItems("*", Qt.MatchWildcard):
if item.checkState() == Qt.Checked:
checkedCols.append(item.data())
uniqueFieldName = ",".join(checkedCols)
elif self.uniqueCombo.currentIndex() >= 0:
uniqueFieldName = self.uniqueModel.item(self.uniqueCombo.currentIndex()).data()
else:
uniqueFieldName = None
else:
uniqueFieldName = None
hasGeomCol = self.hasGeometryCol.checkState() == Qt.Checked
if hasGeomCol:
geomFieldName = self.geomCombo.currentText()
else:
geomFieldName = None
query = self._getSqlQuery()
if query == "":
return None
# remove a trailing ';' from query if present
if query.strip().endswith(';'):
query = query.strip()[:-1]
from qgis.core import QgsMapLayer
layerType = QgsMapLayer.VectorLayer if self.vectorRadio.isChecked() else QgsMapLayer.RasterLayer
# get a new layer name
names = []
for layer in list(QgsProject.instance().mapLayers().values()):
names.append(layer.name())
layerName = self.layerNameEdit.text()
if layerName == "":
layerName = self.defaultLayerName
newLayerName = layerName
index = 1
while newLayerName in names:
index += 1
newLayerName = u"%s_%d" % (layerName, index)
# create the layer
layer = self.db.toSqlLayer(query, geomFieldName, uniqueFieldName, newLayerName, layerType,
self.avoidSelectById.isChecked(), _filter)
if layer.isValid():
return layer
else:
return None
def loadSqlLayer(self):
with OverrideCursor(Qt.WaitCursor):
layer = self._getSqlLayer(self.filter)
if layer is None:
return
QgsProject.instance().addMapLayers([layer], True)
def fillColumnCombos(self):
query = self._getSqlQuery()
if query == "":
return
with OverrideCursor(Qt.WaitCursor):
# remove a trailing ';' from query if present
if query.strip().endswith(';'):
query = query.strip()[:-1]
# get all the columns
cols = []
quotedCols = []
connector = self.db.connector
if self.aliasSubQuery:
# get a new alias
aliasIndex = 0
while True:
alias = "_subQuery__%d" % aliasIndex
escaped = re.compile('\\b("?)' + re.escape(alias) + '\\1\\b')
if not escaped.search(query):
break
aliasIndex += 1
sql = u"SELECT * FROM (%s\n) AS %s LIMIT 0" % (str(query), connector.quoteId(alias))
else:
sql = u"SELECT * FROM (%s\n) WHERE 1=0" % str(query)
c = None
try:
c = connector._execute(None, sql)
cols = connector._get_cursor_columns(c)
for col in cols:
quotedCols.append(connector.quoteId(col))
except BaseError as e:
DlgDbError.showError(e, self)
self.uniqueModel.clear()
self.geomCombo.clear()
return
finally:
if c:
c.close()
del c
self.setColumnCombos(cols, quotedCols)
def setColumnCombos(self, cols, quotedCols):
# get sensible default columns. do this before sorting in case there's hints in the column order (e.g., id is more likely to be first)
try:
defaultGeomCol = next(col for col in cols if col in ['geom', 'geometry', 'the_geom', 'way'])
except:
defaultGeomCol = None
try:
defaultUniqueCol = [col for col in cols if 'id' in col][0]
except:
defaultUniqueCol = None
colNames = sorted(zip(cols, quotedCols))
newItems = []
uniqueIsFilled = False
for (col, quotedCol) in colNames:
item = QStandardItem(col)
item.setData(quotedCol)
item.setEnabled(True)
item.setCheckable(self.allowMultiColumnPk)
item.setSelectable(not self.allowMultiColumnPk)
if self.allowMultiColumnPk:
matchingItems = self.uniqueModel.findItems(col)
if matchingItems:
item.setCheckState(matchingItems[0].checkState())
uniqueIsFilled = uniqueIsFilled or matchingItems[0].checkState() == Qt.Checked
else:
item.setCheckState(Qt.Unchecked)
newItems.append(item)
if self.allowMultiColumnPk:
self.uniqueModel.clear()
self.uniqueModel.appendColumn(newItems)
self.uniqueChanged()
else:
previousUniqueColumn = self.uniqueCombo.currentText()
self.uniqueModel.clear()
self.uniqueModel.appendColumn(newItems)
if self.uniqueModel.findItems(previousUniqueColumn):
self.uniqueCombo.setEditText(previousUniqueColumn)
uniqueIsFilled = True
oldGeometryColumn = self.geomCombo.currentText()
self.geomCombo.clear()
self.geomCombo.addItems(cols)
self.geomCombo.setCurrentIndex(self.geomCombo.findText(oldGeometryColumn, Qt.MatchExactly))
# set sensible default columns if the columns are not already set
try:
if self.geomCombo.currentIndex() == -1:
self.geomCombo.setCurrentIndex(cols.index(defaultGeomCol))
except:
pass
items = self.uniqueModel.findItems(defaultUniqueCol)
if items and not uniqueIsFilled:
if self.allowMultiColumnPk:
items[0].setCheckState(Qt.Checked)
else:
self.uniqueCombo.setEditText(defaultUniqueCol)
try:
pass
except:
pass
def copySelectedResults(self):
if len(self.viewResult.selectedIndexes()) <= 0:
return
model = self.viewResult.model()
# convert to string using tab as separator
text = model.headerToString("\t")
for idx in self.viewResult.selectionModel().selectedRows():
text += "\n" + model.rowToString(idx.row(), "\t")
QApplication.clipboard().setText(text, QClipboard.Selection)
QApplication.clipboard().setText(text, QClipboard.Clipboard)
def initCompleter(self):
dictionary = None
if self.db:
dictionary = self.db.connector.getSqlDictionary()
if not dictionary:
# use the generic sql dictionary
from .sql_dictionary import getSqlDictionary
dictionary = getSqlDictionary()
wordlist = []
for name, value in list(dictionary.items()):
wordlist += value # concat lists
wordlist = list(set(wordlist)) # remove duplicates
api = QsciAPIs(self.editSql.lexer())
for word in wordlist:
api.add(word)
api.prepare()
self.editSql.lexer().setAPIs(api)
def displayQueryBuilder(self):
dlg = QueryBuilderDlg(self.iface, self.db, self, reset=self.queryBuilderFirst)
self.queryBuilderFirst = False
r = dlg.exec_()
if r == QDialog.Accepted:
self.editSql.setText(dlg.query)
def createView(self):
name, ok = QInputDialog.getText(None, "View name", "View name")
if ok:
try:
self.db.connector.createSpatialView(name, self._getSqlQuery())
except BaseError as e:
DlgDbError.showError(e, self)
def _getSqlQuery(self):
sql = self.editSql.selectedText()
if len(sql) == 0:
sql = self.editSql.text()
return sql
def uniqueChanged(self):
# when an item is (un)checked, simply trigger an update of the combobox text
self.uniqueTextChanged(None)
def uniqueTextChanged(self, text):
# Whenever there is new text displayed in the combobox, check if it is the correct one and if not, display the correct one.
checkedItems = []
for item in self.uniqueModel.findItems("*", Qt.MatchWildcard):
if item.checkState() == Qt.Checked:
checkedItems.append(item.text())
label = ", ".join(checkedItems)
if text != label:
self.uniqueCombo.setEditText(label)
def setFilter(self):
from qgis.gui import QgsQueryBuilder
layer = self._getSqlLayer("")
if not layer:
return
dlg = QgsQueryBuilder(layer)
dlg.setSql(self.filter)
if dlg.exec_():
self.filter = dlg.sql()
layer.deleteLater()
class ConfigDialog(BASE, WIDGET):
def __init__(self):
super(ConfigDialog, self).__init__(None)
self.setupUi(self)
self.groupIcon = QIcon()
self.groupIcon.addPixmap(
self.style().standardPixmap(QStyle.SP_DirClosedIcon), QIcon.Normal,
QIcon.Off)
self.groupIcon.addPixmap(
self.style().standardPixmap(QStyle.SP_DirOpenIcon), QIcon.Normal,
QIcon.On)
if hasattr(self.searchBox, 'setPlaceholderText'):
self.searchBox.setPlaceholderText(self.tr('Search...'))
self.model = QStandardItemModel()
self.tree.setModel(self.model)
self.delegate = SettingDelegate()
self.tree.setItemDelegateForColumn(1, self.delegate)
self.searchBox.textChanged.connect(self.textChanged)
self.fillTree()
self.saveMenus = False
self.tree.expanded.connect(self.itemExpanded)
def textChanged(self):
text = str(self.searchBox.text().lower())
self._filterItem(self.model.invisibleRootItem(), text)
if text:
self.tree.expandAll()
else:
self.tree.collapseAll()
def _filterItem(self, item, text):
if item.hasChildren():
show = False
for i in range(item.rowCount()):
child = item.child(i)
showChild = self._filterItem(child, text)
show = (showChild or show)
self.tree.setRowHidden(item.row(), item.index().parent(), not show)
return show
elif isinstance(item, QStandardItem):
hide = bool(text) and (text not in item.text().lower())
self.tree.setRowHidden(item.row(), item.index().parent(), hide)
return not hide
def fillTree(self):
self.fillTreeUsingProviders()
def fillTreeUsingProviders(self):
self.items = {}
self.model.clear()
self.model.setHorizontalHeaderLabels(
[self.tr('Setting'), self.tr('Value')])
settings = ProcessingConfig.getSettings()
rootItem = self.model.invisibleRootItem()
"""
Filter 'General', 'Models' and 'Scripts' items
"""
priorityKeys = [
self.tr('General'),
self.tr('Models'),
self.tr('Scripts')
]
for group in priorityKeys:
groupItem = QStandardItem(group)
icon = ProcessingConfig.getGroupIcon(group)
groupItem.setIcon(icon)
groupItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [groupItem, emptyItem])
# add menu item only if it has any search matches
for setting in settings[group]:
if setting.hidden or setting.name.startswith("MENU_"):
continue
labelItem = QStandardItem(setting.description)
labelItem.setIcon(icon)
labelItem.setEditable(False)
self.items[setting] = SettingItem(setting)
groupItem.insertRow(0, [labelItem, self.items[setting]])
"""
Filter 'Providers' items
"""
providersItem = QStandardItem(self.tr('Providers'))
icon = QgsApplication.getThemeIcon("/processingAlgorithm.svg")
providersItem.setIcon(icon)
providersItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [providersItem, emptyItem])
for group in list(settings.keys()):
if group in priorityKeys or group == menusSettingsGroup:
continue
groupItem = QStandardItem(group)
icon = ProcessingConfig.getGroupIcon(group)
groupItem.setIcon(icon)
groupItem.setEditable(False)
for setting in settings[group]:
if setting.hidden:
continue
labelItem = QStandardItem(setting.description)
labelItem.setIcon(icon)
labelItem.setEditable(False)
self.items[setting] = SettingItem(setting)
groupItem.insertRow(0, [labelItem, self.items[setting]])
emptyItem = QStandardItem()
emptyItem.setEditable(False)
providersItem.appendRow([groupItem, emptyItem])
"""
Filter 'Menus' items
"""
self.menusItem = QStandardItem(self.tr('Menus'))
icon = QIcon(os.path.join(pluginPath, 'images', 'menu.png'))
self.menusItem.setIcon(icon)
self.menusItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [self.menusItem, emptyItem])
button = QPushButton(self.tr('Reset to defaults'))
button.clicked.connect(self.resetMenusToDefaults)
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(button)
layout.addStretch()
widget = QWidget()
widget.setLayout(layout)
self.tree.setIndexWidget(emptyItem.index(), widget)
for provider in QgsApplication.processingRegistry().providers():
providerDescription = provider.name()
groupItem = QStandardItem(providerDescription)
icon = provider.icon()
groupItem.setIcon(icon)
groupItem.setEditable(False)
for alg in provider.algorithms():
algItem = QStandardItem(alg.displayName())
algItem.setIcon(icon)
algItem.setEditable(False)
try:
settingMenu = ProcessingConfig.settings["MENU_" + alg.id()]
settingButton = ProcessingConfig.settings["BUTTON_" +
alg.id()]
settingIcon = ProcessingConfig.settings["ICON_" + alg.id()]
except:
continue
self.items[settingMenu] = SettingItem(settingMenu)
self.items[settingButton] = SettingItem(settingButton)
self.items[settingIcon] = SettingItem(settingIcon)
menuLabelItem = QStandardItem("Menu path")
menuLabelItem.setEditable(False)
buttonLabelItem = QStandardItem("Add button in toolbar")
buttonLabelItem.setEditable(False)
iconLabelItem = QStandardItem("Icon")
iconLabelItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
algItem.insertRow(0, [menuLabelItem, self.items[settingMenu]])
algItem.insertRow(0,
[buttonLabelItem, self.items[settingButton]])
algItem.insertRow(0, [iconLabelItem, self.items[settingIcon]])
groupItem.insertRow(0, [algItem, emptyItem])
emptyItem = QStandardItem()
emptyItem.setEditable(False)
self.menusItem.appendRow([groupItem, emptyItem])
self.tree.sortByColumn(0, Qt.AscendingOrder)
self.adjustColumns()
def resetMenusToDefaults(self):
for provider in QgsApplication.processingRegistry().providers():
for alg in provider.algorithms():
d = defaultMenuEntries.get(alg.id(), "")
setting = ProcessingConfig.settings["MENU_" + alg.id()]
item = self.items[setting]
item.setData(d, Qt.EditRole)
self.saveMenus = True
def accept(self):
qsettings = QgsSettings()
for setting in list(self.items.keys()):
if setting.group != menusSettingsGroup or self.saveMenus:
if isinstance(setting.value, bool):
setting.setValue(
self.items[setting].checkState() == Qt.Checked)
else:
try:
setting.setValue(str(self.items[setting].text()))
except ValueError as e:
QMessageBox.warning(
self, self.tr('Wrong value'),
self.tr('Wrong value for parameter "{0}":\n\n{1}').
format(setting.description, str(e)))
return
setting.save(qsettings)
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
for p in QgsApplication.processingRegistry().providers():
p.refreshAlgorithms()
QApplication.restoreOverrideCursor()
settingsWatcher.settingsChanged.emit()
def itemExpanded(self, idx):
if idx == self.menusItem.index():
self.saveMenus = True
self.adjustColumns()
def adjustColumns(self):
self.tree.resizeColumnToContents(0)
self.tree.resizeColumnToContents(1)
class QRAVEDockWidget(QDockWidget, Ui_QRAVEDockWidgetBase):
closingPlugin = pyqtSignal()
dataChange = pyqtSignal()
showMeta = pyqtSignal()
metaChange = pyqtSignal(str, str, dict, bool)
def __init__(self, parent=None):
"""Constructor."""
super(QRAVEDockWidget, self).__init__(parent)
self.setupUi(self)
self.menu = ContextMenu()
self.qproject = QgsProject.instance()
self.qproject.cleared.connect(self.close_all)
self.treeView.setContextMenuPolicy(Qt.CustomContextMenu)
self.treeView.customContextMenuRequested.connect(self.open_menu)
self.treeView.doubleClicked.connect(self.default_tree_action)
self.treeView.clicked.connect(self.item_change)
self.treeView.expanded.connect(self.expand_tree_item)
self.settings = Settings()
self.model = QStandardItemModel()
self.loaded_projects: List(Project) = []
# Initialize our classes
self.basemaps = BaseMaps()
self.treeView.setModel(self.model)
self.dataChange.connect(self.reload_tree)
self.reload_tree()
def expand_tree_item(self, idx: QModelIndex):
item = self.model.itemFromIndex(idx)
item_data = item.data(Qt.UserRole)
if item_data and item_data.data and isinstance(item_data.data, QRaveBaseMap):
item_data.data.load_layers()
def _get_project(self, xml_path):
try:
return next(iter(self.loaded_projects))
except Exception:
return None
@pyqtSlot()
def reload_tree(self):
# re-initialize our model and reload the projects from file
# Try not to do this too often if you can
self.model.clear()
self.loaded_projects = []
qrave_projects = self.get_project_settings()
for project_path in qrave_projects:
project = Project(project_path)
project.load()
if project is not None and project.exists is True and project.qproject is not None:
self.model.appendRow(project.qproject)
self.expand_children_recursive(self.model.indexFromItem(project.qproject))
self.loaded_projects.append(project)
# Load the tree objects
self.basemaps.load()
# Now load the basemaps
region = self.settings.getValue('basemapRegion')
if self.settings.getValue('basemapsInclude') is True \
and region is not None and len(region) > 0 \
and region in self.basemaps.regions.keys():
self.model.appendRow(self.basemaps.regions[region])
self.expand_children_recursive(self.model.indexFromItem(self.basemaps.regions[region]))
def get_project_settings(self):
try:
qrave_projects_raw, type_conversion_ok = self.qproject.readEntry(
CONSTANTS['settingsCategory'],
'qrave_projects'
)
if type_conversion_ok is False:
qrave_projects = []
else:
qrave_projects = json.loads(qrave_projects_raw)
if qrave_projects is None or not isinstance(qrave_projects, list):
qrave_projects = []
except Exception as e:
self.settings.log('Error loading project settings: {}'.format(e), Qgis.Warning)
qrave_projects = []
filtered = [pf for pf in qrave_projects if os.path.isfile(pf)]
filtered.reverse()
# We Treat this like a stack where the last project in goes on the top.
# Element 0 should be the top item
return filtered
def set_project_settings(self, projects: List[str]):
self.qproject.writeEntry(CONSTANTS['settingsCategory'], 'qrave_projects', json.dumps(projects))
@pyqtSlot()
def add_project(self, xml_path: str):
qrave_projects = self.get_project_settings()
# If this project is not already in
if xml_path not in qrave_projects:
qrave_projects.append(xml_path)
self.set_project_settings(qrave_projects)
self.reload_tree()
new_project = self._get_project(xml_path)
# If this is a fresh load and the setting is set we load the default view
load_default_setting = self.settings.getValue('loadDefaultView')
if load_default_setting is True \
and new_project.default_view is not None \
and new_project.default_view in new_project.views:
self.add_children_to_map(new_project.qproject, new_project.views[new_project.default_view])
def closeEvent(self, event):
""" When the user clicks the "X" in the dockwidget titlebar
"""
self.hide()
self.qproject.removeEntry(CONSTANTS['settingsCategory'], 'enabled')
self.closingPlugin.emit()
event.accept()
def expand_children_recursive(self, idx: QModelIndex = None, force=False):
"""Expand all the children of a QTreeView node. Do it recursively
TODO: Recursion might not be the best for large trees here.
Args:
idx (QModelIndex, optional): [description]. Defaults to None.
force: ignore the "collapsed" business logic attribute
"""
if idx is None:
idx = self.treeView.rootIndex()
for idy in range(self.model.rowCount(idx)):
child = self.model.index(idy, 0, idx)
self.expand_children_recursive(child, force)
item = self.model.itemFromIndex(idx)
item_data = item.data(Qt.UserRole) if item is not None else None
# NOTE: This is pretty verbose on purpose
# This thing needs to have data or it defaults to being expanded
if item_data is None or item_data.data is None:
collapsed = False
# Collapsed is an attribute set in the business logic
# Never expand the QRaveBaseMap object becsause there's a network call involved
elif isinstance(item_data.data, QRaveBaseMap) \
or (isinstance(item_data.data, dict) and 'collapsed' in item_data.data and item_data.data['collapsed'] == 'true'):
collapsed = True
else:
collapsed = False
if not self.treeView.isExpanded(idx) and not collapsed:
self.treeView.setExpanded(idx, True)
def default_tree_action(self, idx: QModelIndex):
if not idx.isValid():
return
item = self.model.itemFromIndex(idx)
item_data: ProjectTreeData = item.data(Qt.UserRole)
# This is the default action for all add-able layers including basemaps
if isinstance(item_data.data, QRaveMapLayer):
if item_data.data.layer_type in [QRaveMapLayer.LayerTypes.FILE, QRaveMapLayer.LayerTypes.REPORT]:
self.file_system_open(item_data.data.layer_uri)
else:
QRaveMapLayer.add_layer_to_map(item)
# Expand is the default option for wms because we might need to load the layers
elif isinstance(item_data.data, QRaveBaseMap):
if item_data.data.tile_type == 'wms':
pass
# All the XYZ layers can be added normally.
else:
QRaveMapLayer.add_layer_to_map(item)
elif item_data.type in [QRaveTreeTypes.PROJECT_ROOT]:
self.change_meta(item, item_data, True)
# For folder-y types we want Expand and contract is already implemented as a default
elif item_data.type in [
QRaveTreeTypes.PROJECT_FOLDER,
QRaveTreeTypes.PROJECT_REPEATER_FOLDER,
QRaveTreeTypes.PROJECT_VIEW_FOLDER,
QRaveTreeTypes.BASEMAP_ROOT,
QRaveTreeTypes.BASEMAP_SUPER_FOLDER,
QRaveTreeTypes.BASEMAP_SUB_FOLDER
]:
# print("Default Folder Action")
pass
elif item_data.type == QRaveTreeTypes.PROJECT_VIEW:
print("Default View Action")
self.add_view_to_map(item_data)
def item_change(self, pos):
"""Triggered when the user selects a new item in the tree
Args:pos
pos ([type]): [description]
"""
indexes = self.treeView.selectedIndexes()
# No multiselect so there is only ever one item
item = self.model.itemFromIndex(indexes[0])
data_item: ProjectTreeData = item.data(Qt.UserRole)
if len(indexes) < 1 or data_item.project is None or not data_item.project.exists:
return
# Update the metadata if we need to
self.change_meta(item, data_item)
def change_meta(self, item: QStandardItem, item_data: ProjectTreeData, show=False):
"""Update the MetaData dock widget with new information
Args:
item (QStandardItem): [description]
data ([type]): [description]
show (bool, optional): [description]. Defaults to False.
"""
data = item_data.data
if isinstance(data, QRaveMapLayer):
meta = data.meta if data.meta is not None else {}
self.metaChange.emit(item.text(), MetaType.LAYER, meta, show)
elif isinstance(data, QRaveBaseMap):
self.metaChange.emit(item.text(), MetaType.NONE, {}, show)
elif item_data.type == QRaveTreeTypes.PROJECT_ROOT:
self.metaChange.emit(item.text(), MetaType.PROJECT, {
'project': item_data.project.meta,
'warehouse': item_data.project.warehouse_meta
}, show)
elif item_data.type in [
QRaveTreeTypes.PROJECT_FOLDER,
QRaveTreeTypes.PROJECT_REPEATER_FOLDER,
QRaveTreeTypes.PROJECT_VIEW_FOLDER,
QRaveTreeTypes.BASEMAP_ROOT,
QRaveTreeTypes.BASEMAP_SUPER_FOLDER,
QRaveTreeTypes.BASEMAP_SUB_FOLDER
]:
self.metaChange.emit(item.text(), MetaType.FOLDER, data or {}, show)
elif isinstance(data, dict):
# this is just the generic case for any kind of metadata
self.metaChange.emit(item.text(), MetaType.NONE, data or {}, show)
else:
# Do not update the metadata if we have nothing to show
self.metaChange.emit(item.text(), MetaType.NONE, {}, show)
def get_warehouse_url(self, wh_meta: Dict[str, str]):
if wh_meta is not None:
if 'program' in wh_meta and 'id' in wh_meta:
return '/'.join([CONSTANTS['warehouseUrl'], wh_meta['program'], wh_meta['id']])
elif '_rs_wh_id' in wh_meta and '_rs_wh_program' in wh_meta:
return '/'.join([CONSTANTS['warehouseUrl'], wh_meta['_rs_wh_program'], wh_meta['_rs_wh_id']])
return None
def project_warehouse_view(self, project: Project):
"""Open this project in the warehouse if the warehouse meta entries exist
"""
url = self.get_warehouse_url(project.warehouse_meta)
if url is not None:
QDesktopServices.openUrl(QUrl(url))
def layer_warehouse_view(self, data: QRaveMapLayer):
"""Open this project in the warehouse if the warehouse meta entries exist
"""
url = self.get_warehouse_url(data.meta)
if url is not None:
QDesktopServices.openUrl(QUrl(url))
def close_all(self):
for p in range(len(self.loaded_projects)):
self.close_project(self.loaded_projects[0])
def close_project(self, project: Project):
""" Close the project
"""
try:
qrave_projects_raw, type_conversion_ok = self.qproject.readEntry(
CONSTANTS['settingsCategory'],
'qrave_projects'
)
qrave_projects = json.loads(qrave_projects_raw)
if not type_conversion_ok or qrave_projects is None:
qrave_projects = []
except Exception as e:
self.settings.log('Error closing project: {}'.format(e), Qgis.Warning)
qrave_projects = []
# Filter out the project we want to close and reload the tree
qrave_projects = [x.project_xml_path for x in self.loaded_projects if x != project]
# Write the settings back to the project
self.qproject.writeEntry(CONSTANTS['settingsCategory'], 'qrave_projects', json.dumps(qrave_projects))
self.loaded_projects = qrave_projects
self.reload_tree()
def file_system_open(self, fpath: str):
"""Open a file on the operating system using the default action
Args:
fpath (str): [description]
"""
qurl = QUrl.fromLocalFile(fpath)
QDesktopServices.openUrl(QUrl(qurl))
def file_system_locate(self, fpath: str):
"""This the OS-agnostic "show in Finder" or "show in explorer" equivalent
It should open the folder of the item in question
Args:
fpath (str): [description]
"""
final_path = os.path.dirname(fpath)
while not os.path.isdir(final_path):
final_path = os.path.dirname(final_path)
qurl = QUrl.fromLocalFile(final_path)
QDesktopServices.openUrl(qurl)
def toggleSubtree(self, item: QStandardItem = None, expand=True):
def _recurse(curritem):
idx = self.model.indexFromItem(item)
if expand is not self.treeView.isExpanded(idx):
self.treeView.setExpanded(idx, expand)
for row in range(curritem.rowCount()):
_recurse(curritem.child(row))
if item is None:
if expand is True:
self.treeView.expandAll()
else:
self.treeView.collapseAll()
else:
_recurse(item)
def add_view_to_map(self, item_data: ProjectTreeData):
"""Add a view and all its layers to the map
Args:
item (QStandardItem): [description]
"""
self.add_children_to_map(item_data.project.qproject, item_data.data)
def add_children_to_map(self, item: QStandardItem, bl_ids: List[str] = None):
"""Iteratively add all children to the map
Args:
item (QStandardItem): [description]
bl_ids (List[str], optional): List of ids to filter by so we don't load everything. this is used for loading views
"""
for child in self._get_children(item):
# Is this something we can add to the map?
project_tree_data = child.data(Qt.UserRole)
if project_tree_data is not None and isinstance(project_tree_data.data, QRaveMapLayer):
data = project_tree_data.data
loadme = False
# If this layer matches the businesslogic id filter
if bl_ids is not None and len(bl_ids) > 0:
if 'id' in data.bl_attr and data.bl_attr['id'] in bl_ids:
loadme = True
else:
loadme = True
if loadme is True:
data.add_layer_to_map(child)
def _get_children(self, root_item: QStandardItem):
"""Recursion is going to kill us here so do an iterative solution instead
https://stackoverflow.com/questions/41949370/collect-all-items-in-qtreeview-recursively
Yields:
[type]: [description]
"""
stack = [root_item]
while stack:
parent = stack.pop(0)
for row in range(parent.rowCount()):
for column in range(parent.columnCount()):
child = parent.child(row, column)
yield child
if child.hasChildren():
stack.append(child)
def _get_parents(self, start_item: QStandardItem):
stack = []
placeholder = start_item.parent()
while placeholder is not None and placeholder != self.model.invisibleRootItem():
stack.append(placeholder)
placeholder = start_item.parent()
return stack.reverse()
def open_menu(self, position):
indexes = self.treeView.selectedIndexes()
if len(indexes) < 1:
return
# No multiselect so there is only ever one item
idx = indexes[0]
if not idx.isValid():
return
item = self.model.itemFromIndex(indexes[0])
project_tree_data = item.data(Qt.UserRole) # ProjectTreeData object
data = project_tree_data.data # Could be a QRaveBaseMap, a QRaveMapLayer or just some random data
# This is the layer context menu
if isinstance(data, QRaveMapLayer):
if data.layer_type == QRaveMapLayer.LayerTypes.WEBTILE:
self.basemap_context_menu(idx, item, project_tree_data)
elif data.layer_type in [QRaveMapLayer.LayerTypes.FILE, QRaveMapLayer.LayerTypes.REPORT]:
self.file_layer_context_menu(idx, item, project_tree_data)
else:
self.map_layer_context_menu(idx, item, project_tree_data)
elif isinstance(data, QRaveBaseMap):
# A WMS QARaveBaseMap is just a container for layers
if data.tile_type == 'wms':
self.folder_dumb_context_menu(idx, item, project_tree_data)
# Every other kind of basemap is an add-able layer
else:
self.basemap_context_menu(idx, item, project_tree_data)
elif project_tree_data.type == QRaveTreeTypes.PROJECT_ROOT:
self.project_context_menu(idx, item, project_tree_data)
elif project_tree_data.type in [
QRaveTreeTypes.PROJECT_VIEW_FOLDER,
QRaveTreeTypes.BASEMAP_ROOT,
QRaveTreeTypes.BASEMAP_SUPER_FOLDER
]:
self.folder_dumb_context_menu(idx, item, project_tree_data)
elif project_tree_data.type in [
QRaveTreeTypes.PROJECT_FOLDER,
QRaveTreeTypes.PROJECT_REPEATER_FOLDER,
QRaveTreeTypes.BASEMAP_SUB_FOLDER
]:
self.folder_context_menu(idx, item, project_tree_data)
elif project_tree_data.type == QRaveTreeTypes.PROJECT_VIEW:
self.view_context_menu(idx, item, project_tree_data)
self.menu.exec_(self.treeView.viewport().mapToGlobal(position))
def map_layer_context_menu(self, idx: QModelIndex, item: QStandardItem, item_data: ProjectTreeData):
self.menu.clear()
self.menu.addAction('ADD_TO_MAP', lambda: QRaveMapLayer.add_layer_to_map(item), enabled=item_data.data.exists)
self.menu.addAction('VIEW_LAYER_META', lambda: self.change_meta(item, item_data, True))
if bool(self.get_warehouse_url(item_data.data.meta)):
self.menu.addAction('VIEW_WEB_SOURCE', lambda: self.layer_warehouse_view(item_data))
self.menu.addAction('BROWSE_FOLDER', lambda: self.file_system_locate(item_data.data.layer_uri))
def file_layer_context_menu(self, idx: QModelIndex, item: QStandardItem, item_data: ProjectTreeData):
self.menu.clear()
self.menu.addAction('OPEN_FILE', lambda: self.file_system_open(item_data.data.layer_uri))
self.menu.addAction('BROWSE_FOLDER', lambda: self.file_system_locate(item_data.data.layer_uri))
# Basemap context items
def basemap_context_menu(self, idx: QModelIndex, item: QStandardItem, data: ProjectTreeData):
self.menu.clear()
self.menu.addAction('ADD_TO_MAP', lambda: QRaveMapLayer.add_layer_to_map(item))
# Folder-level context menu
def folder_context_menu(self, idx: QModelIndex, item: QStandardItem, data: ProjectTreeData):
self.menu.clear()
self.menu.addAction('ADD_ALL_TO_MAP', lambda: self.add_children_to_map(item))
self.menu.addSeparator()
self.menu.addAction('COLLAPSE_ALL', lambda: self.toggleSubtree(item, False))
self.menu.addAction('EXPAND_ALL', lambda: self.toggleSubtree(item, True))
# Some folders don't have the 'ADD_ALL_TO_MAP' functionality enabled
def folder_dumb_context_menu(self, idx: QModelIndex, item: QStandardItem, data: ProjectTreeData):
self.menu.clear()
self.menu.addAction('COLLAPSE_ALL', lambda: self.toggleSubtree(item, False))
self.menu.addAction('EXPAND_ALL', lambda: self.toggleSubtree(item, True))
# View context items
def view_context_menu(self, idx: QModelIndex, item: QStandardItem, item_data: ProjectTreeData):
self.menu.clear()
self.menu.addAction('ADD_ALL_TO_MAP', lambda: self.add_view_to_map(item_data))
# Project-level context menu
def project_context_menu(self, idx: QModelIndex, item: QStandardItem, data: ProjectTreeData):
self.menu.clear()
self.menu.addAction('COLLAPSE_ALL', lambda: self.toggleSubtree(None, False))
self.menu.addAction('EXPAND_ALL', lambda: self.toggleSubtree(None, True))
self.menu.addSeparator()
self.menu.addAction('BROWSE_PROJECT_FOLDER', lambda: self.file_system_locate(data.project.project_xml_path))
self.menu.addAction('VIEW_PROJECT_META', lambda: self.change_meta(item, data, True))
self.menu.addAction('WAREHOUSE_VIEW', lambda: self.project_warehouse_view(data.project), enabled=bool(self.get_warehouse_url(data.project.warehouse_meta)))
self.menu.addAction('ADD_ALL_TO_MAP', lambda: self.add_children_to_map(item))
self.menu.addSeparator()
self.menu.addAction('REFRESH_PROJECT_HIERARCHY', self.reload_tree)
self.menu.addAction('CUSTOMIZE_PROJECT_HIERARCHY', enabled=False)
self.menu.addSeparator()
self.menu.addAction('CLOSE_PROJECT', lambda: self.close_project(data.project), enabled=bool(data.project))
