class HTMLFieldSelectionDialog(QDialog, HTML_FIELDS_CLASS):
def __init__(self, iface, feat):
super(HTMLFieldSelectionDialog, self).__init__(iface.mainWindow())
self.setupUi(self)
self.iface = iface
self.feat = feat
self.selected = []
self.selectAllButton.clicked.connect(self.selectAll)
self.clearButton.clicked.connect(self.clearAll)
self.checkBox.stateChanged.connect(self.initModel)
self.initModel()
def initModel(self):
self.model = QStandardItemModel(self.listView)
state = self.checkBox.isChecked()
for key in list(self.feat.keys()):
if state == False or self.feat[key] > 0:
item = QStandardItem()
item.setText(key)
item.setCheckable(True)
item.setSelectable(False)
self.model.appendRow(item)
self.listView.setModel(self.model)
self.listView.show()
def selectAll(self):
cnt = self.model.rowCount()
for i in range(0, cnt):
item = self.model.item(i)
item.setCheckState(Qt.Checked)
def clearAll(self):
cnt = self.model.rowCount()
for i in range(0, cnt):
item = self.model.item(i)
item.setCheckState(Qt.Unchecked)
def accept(self):
self.selected = []
cnt = self.model.rowCount()
for i in range(0, cnt):
item = self.model.item(i)
if item.checkState() == Qt.Checked:
self.selected.append(item.text())
self.close()
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 MultipleInputDialog(BASE, WIDGET):
def __init__(self, options, selectedoptions=None, datatype=None):
super(MultipleInputDialog, self).__init__(None)
self.setupUi(self)
self.datatype = datatype
self.model = None
self.options = []
for i, option in enumerate(options):
if option is None or isinstance(option, str):
self.options.append((i, option))
else:
self.options.append((option[0], option[1]))
self.selectedoptions = selectedoptions or []
# Additional buttons
self.btnSelectAll = QPushButton(self.tr('Select All'))
self.buttonBox.addButton(self.btnSelectAll,
QDialogButtonBox.ActionRole)
self.btnClearSelection = QPushButton(self.tr('Clear Selection'))
self.buttonBox.addButton(self.btnClearSelection,
QDialogButtonBox.ActionRole)
self.btnToggleSelection = QPushButton(self.tr('Toggle Selection'))
self.buttonBox.addButton(self.btnToggleSelection,
QDialogButtonBox.ActionRole)
if self.datatype is not None:
btnAddFile = QPushButton(QCoreApplication.translate("MultipleInputDialog", 'Add File(s)…'))
btnAddFile.clicked.connect(self.addFiles)
self.buttonBox.addButton(btnAddFile,
QDialogButtonBox.ActionRole)
self.btnSelectAll.clicked.connect(lambda: self.selectAll(True))
self.btnClearSelection.clicked.connect(lambda: self.selectAll(False))
self.btnToggleSelection.clicked.connect(self.toggleSelection)
self.settings = QgsSettings()
self.restoreGeometry(self.settings.value("/Processing/multipleInputDialogGeometry", QByteArray()))
self.lstLayers.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.lstLayers.setDragDropMode(QAbstractItemView.InternalMove)
self.populateList()
self.finished.connect(self.saveWindowGeometry)
def saveWindowGeometry(self):
self.settings.setValue("/Processing/multipleInputDialogGeometry", self.saveGeometry())
def populateList(self):
self.model = QStandardItemModel()
for value, text in self.options:
item = QStandardItem(text)
item.setData(value, Qt.UserRole)
item.setCheckState(Qt.Checked if value in self.selectedoptions else Qt.Unchecked)
item.setCheckable(True)
item.setDropEnabled(False)
self.model.appendRow(item)
# add extra options (e.g. manually added layers)
for t in [o for o in self.selectedoptions if not isinstance(o, int)]:
if isinstance(t, QgsProcessingModelChildParameterSource):
item = QStandardItem(t.staticValue())
else:
item = QStandardItem(t)
item.setData(item.text(), Qt.UserRole)
item.setCheckState(Qt.Checked)
item.setCheckable(True)
item.setDropEnabled(False)
self.model.appendRow(item)
self.lstLayers.setModel(self.model)
def accept(self):
self.selectedoptions = []
model = self.lstLayers.model()
for i in range(model.rowCount()):
item = model.item(i)
if item.checkState() == Qt.Checked:
self.selectedoptions.append(item.data(Qt.UserRole))
QDialog.accept(self)
def reject(self):
self.selectedoptions = None
QDialog.reject(self)
def getItemsToModify(self):
items = []
if len(self.lstLayers.selectedIndexes()) > 1:
for i in self.lstLayers.selectedIndexes():
items.append(self.model.itemFromIndex(i))
else:
for i in range(self.model.rowCount()):
items.append(self.model.item(i))
return items
def selectAll(self, value):
for item in self.getItemsToModify():
item.setCheckState(Qt.Checked if value else Qt.Unchecked)
def toggleSelection(self):
for item in self.getItemsToModify():
checked = item.checkState() == Qt.Checked
item.setCheckState(Qt.Unchecked if checked else Qt.Checked)
def getFileFilter(self, datatype):
"""
Returns a suitable file filter pattern for the specified parameter definition
:param param:
:return:
"""
if datatype == QgsProcessing.TypeRaster:
return QgsProviderRegistry.instance().fileRasterFilters()
elif datatype == QgsProcessing.TypeFile:
return self.tr('All files (*.*)')
else:
exts = QgsVectorFileWriter.supportedFormatExtensions()
for i in range(len(exts)):
exts[i] = self.tr('{0} files (*.{1})').format(exts[i].upper(), exts[i].lower())
return self.tr('All files (*.*)') + ';;' + ';;'.join(exts)
def addFiles(self):
filter = self.getFileFilter(self.datatype)
settings = QgsSettings()
path = str(settings.value('/Processing/LastInputPath'))
ret, selected_filter = QFileDialog.getOpenFileNames(self, self.tr('Select File(s)'),
path, filter)
if ret:
files = list(ret)
settings.setValue('/Processing/LastInputPath',
os.path.dirname(str(files[0])))
for filename in files:
item = QStandardItem(filename)
item.setData(filename, Qt.UserRole)
item.setCheckState(Qt.Checked)
item.setCheckable(True)
item.setDropEnabled(False)
self.model.appendRow(item)
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 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 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 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(
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 DialogExportData(QDialog, DIALOG_UI):
on_result = pyqtSignal(
bool) # whether the tool was run successfully or not
ValidExtensions = ['xtf', 'itf', 'gml', 'xml']
current_row_schema = 0
def __init__(self, iface, qgis_utils, conn_manager, context):
QDialog.__init__(self)
self.setupUi(self)
QgsGui.instance().enableAutoGeometryRestore(self)
self.iface = iface
self.conn_manager = conn_manager
self.db_source = context.get_db_sources()[0]
self.db = self.conn_manager.get_db_connector_from_source(
self.db_source)
self.qgis_utils = qgis_utils
self.logger = Logger()
self.java_utils = JavaUtils()
self.java_utils.download_java_completed.connect(
self.download_java_complete)
self.java_utils.download_java_progress_changed.connect(
self.download_java_progress_change)
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self.ilicache.refresh()
self._dbs_supported = ConfigDbSupported()
self._running_tool = False
# There may be 1 case where we need to emit a db_connection_changed from the Export Data dialog:
# 1) Connection Settings was opened and the DB conn was changed.
self._db_was_changed = False # To postpone calling refresh gui until we close this dialog instead of settings
# Similarly, we could call a refresh on layers and relations cache in 1 case:
# 1) If the ED dialog was called for the COLLECTED source: opening Connection Settings and changing the DB
# connection.
self._schedule_layers_and_relations_refresh = False
# We need bar definition above calling clear_messages
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.xtf_file_browse_button.clicked.connect(
make_save_file_selector(
self.xtf_file_line_edit,
title=QCoreApplication.translate("DialogExportData",
"Save in XTF Transfer File"),
file_filter=QCoreApplication.translate(
"DialogExportData",
"XTF Transfer File (*.xtf);;Interlis 1 Transfer File (*.itf);;XML (*.xml);;GML (*.gml)"
),
extension='.xtf',
extensions=['.' + ext for ext in self.ValidExtensions]))
self.xtf_file_browse_button.clicked.connect(
self.xtf_browser_opened_to_true)
self.xtf_browser_was_opened = False
self.validators = Validators()
fileValidator = FileValidator(
pattern=['*.' + ext for ext in self.ValidExtensions],
allow_non_existing=True)
self.xtf_file_line_edit.setPlaceholderText(
QCoreApplication.translate("DialogExportData",
"[Name of the XTF to be created]"))
self.xtf_file_line_edit.setValidator(fileValidator)
self.xtf_file_line_edit.textChanged.connect(
self.validators.validate_line_edits)
self.xtf_file_line_edit.textChanged.connect(
self.xtf_browser_opened_to_false)
self.xtf_file_line_edit.textChanged.emit(
self.xtf_file_line_edit.text())
self.connection_setting_button.clicked.connect(self.show_settings)
self.connection_setting_button.setText(
QCoreApplication.translate("DialogExportData",
"Connection Settings"))
# LOG
self.log_config.setTitle(
QCoreApplication.translate("DialogExportData", "Show log"))
self.log_config.setFlat(True)
self.buttonBox.accepted.disconnect()
self.buttonBox.accepted.connect(self.accepted)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self._accept_button = self.buttonBox.addButton(
QCoreApplication.translate("DialogExportData", "Export data"),
QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
self.update_connection_info()
self.update_model_names()
self.restore_configuration()
def update_connection_info(self):
db_description = self.db.get_description_conn_string()
if db_description:
self.db_connect_label.setText(db_description)
self.db_connect_label.setToolTip(self.db.get_display_conn_string())
self._accept_button.setEnabled(True)
else:
self.db_connect_label.setText(
QCoreApplication.translate("DialogExportData",
"The database is not defined!"))
self.db_connect_label.setToolTip('')
self._accept_button.setEnabled(False)
def update_model_names(self):
self.export_models_qmodel = QStandardItemModel()
model_names = self.db.get_models()
if model_names:
for model_name in model_names:
if model_name not in LADMNames.DEFAULT_HIDDEN_MODELS:
item = QStandardItem(model_name)
item.setCheckable(False)
item.setEditable(False)
self.export_models_qmodel.appendRow(item)
self.export_models_list_view.setModel(self.export_models_qmodel)
def reject(self):
if self._running_tool:
QMessageBox.information(
self, QCoreApplication.translate("DialogExportData",
"Warning"),
QCoreApplication.translate(
"DialogExportData",
"The Export Data tool is still running. Please wait until it finishes."
))
else:
self.close_dialog()
def close_dialog(self):
"""
We use this method to be safe when emitting the db_connection_changed, otherwise we could trigger slots that
unload the plugin, destroying dialogs and thus, leading to crashes.
"""
if self._schedule_layers_and_relations_refresh:
self.conn_manager.db_connection_changed.connect(
self.qgis_utils.cache_layers_and_relations)
if self._db_was_changed:
# If the db was changed, it implies it complies with ladm_col, hence the second parameter
self.conn_manager.db_connection_changed.emit(
self.db, True, self.db_source)
if self._schedule_layers_and_relations_refresh:
self.conn_manager.db_connection_changed.disconnect(
self.qgis_utils.cache_layers_and_relations)
self.logger.info(__name__, "Dialog closed.")
self.done(QDialog.Accepted)
def get_ili_models(self):
ili_models = list()
for index in range(self.export_models_qmodel.rowCount()):
item = self.export_models_qmodel.item(index)
ili_models.append(item.text())
return ili_models
def show_settings(self):
# We only need those tabs related to Model Baker/ili2db operations
dlg = SettingsDialog(qgis_utils=self.qgis_utils,
conn_manager=self.conn_manager)
dlg.set_db_source(self.db_source)
dlg.set_tab_pages_list(
[SETTINGS_CONNECTION_TAB_INDEX, SETTINGS_MODELS_TAB_INDEX])
# Connect signals (DBUtils, QgisUtils)
dlg.db_connection_changed.connect(self.db_connection_changed)
if self.db_source == COLLECTED_DB_SOURCE:
self._schedule_layers_and_relations_refresh = True
dlg.set_action_type(EnumDbActionType.EXPORT)
if dlg.exec_():
self.db = dlg.get_db_connection()
self.update_model_names()
self.update_connection_info()
def db_connection_changed(self, db, ladm_col_db, db_source):
self._db_was_changed = True
self.clear_messages()
def accepted(self):
self._running_tool = True
self.bar.clearWidgets()
java_home_set = self.java_utils.set_java_home()
if not java_home_set:
message_java = QCoreApplication.translate(
"DialogExportData",
"""Configuring Java {}...""").format(JAVA_REQUIRED_VERSION)
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
self.txtStdout.setText(message_java)
self.java_utils.get_java_on_demand()
self.disable()
return
configuration = self.update_configuration()
if not self.xtf_file_line_edit.validator().validate(
configuration.xtffile, 0)[0] == QValidator.Acceptable:
self._running_tool = False
message_error = QCoreApplication.translate(
"DialogExportData",
"Please set a valid XTF file before exporting data.")
self.txtStdout.setText(message_error)
self.show_message(message_error, Qgis.Warning)
self.xtf_file_line_edit.setFocus()
return
if not self.get_ili_models():
self._running_tool = False
message_error = QCoreApplication.translate(
"DialogExportData",
"Please set a valid schema to export. This schema does not have information to export."
)
self.txtStdout.setText(message_error)
self.show_message(message_error, Qgis.Warning)
self.export_models_list_view.setFocus()
return
if not configuration.iliexportmodels:
self._running_tool = False
message_error = QCoreApplication.translate(
"DialogExportData",
"Please set a model before exporting data.")
self.txtStdout.setText(message_error)
self.show_message(message_error, Qgis.Warning)
self.export_models_list_view.setFocus()
return
# If xtf browser was opened and the file exists, the user already chose
# to overwrite the file
if os.path.isfile(self.xtf_file_line_edit.text().strip()
) and not self.xtf_browser_was_opened:
self.msg = QMessageBox()
self.msg.setIcon(QMessageBox.Warning)
self.msg.setText(
QCoreApplication.translate(
"DialogExportData",
"{filename} already exists.\nDo you want to replace it?").
format(filename=os.path.basename(
self.xtf_file_line_edit.text().strip())))
self.msg.setWindowTitle(
QCoreApplication.translate("DialogExportData",
"Save in XTF Transfer File"))
self.msg.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
msg_box = self.msg.exec_()
if msg_box == QMessageBox.No:
self._running_tool = False
return
with OverrideCursor(Qt.WaitCursor):
self.progress_bar.show()
self.disable()
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
exporter = iliexporter.Exporter()
db_factory = self._dbs_supported.get_db_factory(self.db.engine)
exporter.tool = db_factory.get_mbaker_db_ili_mode()
exporter.configuration = configuration
self.save_configuration(configuration)
exporter.stdout.connect(self.print_info)
exporter.stderr.connect(self.on_stderr)
exporter.process_started.connect(self.on_process_started)
exporter.process_finished.connect(self.on_process_finished)
self.progress_bar.setValue(25)
try:
if exporter.run() != iliexporter.Exporter.SUCCESS:
self._running_tool = False
self.show_message(
QCoreApplication.translate(
"DialogExportData",
"An error occurred when exporting the data. For more information see the log..."
), Qgis.Warning)
self.on_result.emit(
False
) # Inform other classes that the execution was not successful
return
except JavaNotFoundError:
self._running_tool = False
message_error_java = QCoreApplication.translate(
"DialogExportData",
"Java {} could not be found. You can configure the JAVA_HOME environment variable manually, restart QGIS and try again."
).format(JAVA_REQUIRED_VERSION)
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
self.txtStdout.setText(message_error_java)
self.show_message(message_error_java, Qgis.Warning)
return
self._running_tool = False
self.buttonBox.clear()
self.buttonBox.setEnabled(True)
self.buttonBox.addButton(QDialogButtonBox.Close)
self.progress_bar.setValue(100)
self.show_message(
QCoreApplication.translate(
"DialogExportData",
"Export of the data was successfully completed."),
Qgis.Success)
self.on_result.emit(
True) # Inform other classes that the execution was successful
def download_java_complete(self):
self.accepted()
def download_java_progress_change(self, progress):
self.progress_bar.setValue(progress / 2)
if (progress % 20) == 0:
self.txtStdout.append('...')
def save_configuration(self, configuration):
settings = QSettings()
settings.setValue(
'Asistente-LADM_COL/QgisModelBaker/ili2pg/xtffile_export',
configuration.xtffile)
settings.setValue('Asistente-LADM_COL/QgisModelBaker/show_log',
not self.log_config.isCollapsed())
def restore_configuration(self):
settings = QSettings()
self.xtf_file_line_edit.setText(
settings.value(
'Asistente-LADM_COL/QgisModelBaker/ili2pg/xtffile_export'))
# Show log
value_show_log = settings.value(
'Asistente-LADM_COL/QgisModelBaker/show_log', False, type=bool)
self.log_config.setCollapsed(not value_show_log)
# set model repository
# if there is no option by default use online model repository
custom_model_is_checked = settings.value(
'Asistente-LADM_COL/models/custom_model_directories_is_checked',
DEFAULT_USE_CUSTOM_MODELS,
type=bool)
if custom_model_is_checked:
self.custom_model_directories = settings.value(
'Asistente-LADM_COL/models/custom_models', DEFAULT_MODELS_DIR)
def update_configuration(self):
"""
Get the configuration that is updated with the user configuration changes on the dialog.
:return: Configuration
"""
db_factory = self._dbs_supported.get_db_factory(self.db.engine)
configuration = ExportConfiguration()
db_factory.set_ili2db_configuration_params(self.db.dict_conn_params,
configuration)
configuration.xtffile = self.xtf_file_line_edit.text().strip()
full_java_exe_path = JavaUtils.get_full_java_exe_path()
if full_java_exe_path:
self.base_configuration.java_path = full_java_exe_path
# User could have changed the default values
self.use_local_models = QSettings().value(
'Asistente-LADM_COL/models/custom_model_directories_is_checked',
DEFAULT_USE_CUSTOM_MODELS,
type=bool)
self.custom_model_directories = QSettings().value(
'Asistente-LADM_COL/models/custom_models', DEFAULT_MODELS_DIR)
# Check custom model directories
if self.use_local_models:
if not self.custom_model_directories:
self.base_configuration.custom_model_directories_enabled = False
else:
self.base_configuration.custom_model_directories = self.custom_model_directories
self.base_configuration.custom_model_directories_enabled = True
configuration.base_configuration = self.base_configuration
if self.get_ili_models():
configuration.iliexportmodels = ';'.join(self.get_ili_models())
configuration.ilimodels = ';'.join(self.get_ili_models())
configuration.disable_validation = not QSettings().value(
'Asistente-LADM_COL/advanced_settings/validate_data_importing_exporting',
True, bool)
return configuration
def print_info(self, text, text_color='#000000', clear=False):
self.txtStdout.setTextColor(QColor(text_color))
self.txtStdout.append(text)
QCoreApplication.processEvents()
def on_stderr(self, text):
color_log_text(text, self.txtStdout)
self.advance_progress_bar_by_text(text)
def on_process_started(self, command):
self.disable()
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
self.txtStdout.setText(command)
QCoreApplication.processEvents()
def on_process_finished(self, exit_code, result):
color = '#004905' if exit_code == 0 else '#aa2222'
self.txtStdout.setTextColor(QColor(color))
self.txtStdout.append(
QCoreApplication.translate("DialogExportData",
"Finished ({})").format(exit_code))
if result == iliexporter.Exporter.SUCCESS:
self.buttonBox.clear()
self.buttonBox.setEnabled(True)
self.buttonBox.addButton(QDialogButtonBox.Close)
else:
self.enable()
# Open log
if self.log_config.isCollapsed():
self.log_config.setCollapsed(False)
def advance_progress_bar_by_text(self, text):
if text.strip() == 'Info: compile models...':
self.progress_bar.setValue(50)
QCoreApplication.processEvents()
elif text.strip() == 'Info: process data...':
self.progress_bar.setValue(55)
QCoreApplication.processEvents()
elif text.strip() == 'Info: first validation pass...':
self.progress_bar.setValue(70)
QCoreApplication.processEvents()
elif text.strip() == 'Info: second validation pass...':
self.progress_bar.setValue(85)
QCoreApplication.processEvents()
def clear_messages(self):
self.bar.clearWidgets(
) # Remove previous messages before showing a new one
self.txtStdout.clear() # Clear previous log messages
self.progress_bar.setValue(0) # Initialize progress bar
def show_help(self):
self.qgis_utils.show_help("export_data")
def disable(self):
self.db_config.setEnabled(False)
self.ili_config.setEnabled(False)
self.buttonBox.setEnabled(False)
def enable(self):
self.db_config.setEnabled(True)
self.ili_config.setEnabled(True)
self.buttonBox.setEnabled(True)
def show_message(self, message, level):
if level == Qgis.Warning:
self.enable()
self.bar.clearWidgets(
) # Remove previous messages before showing a new one
self.bar.pushMessage("Asistente LADM_COL", message, level, duration=0)
def xtf_browser_opened_to_true(self):
"""
Slot. Sets a flag to true to eventually avoid asking a user whether to overwrite a file.
"""
self.xtf_browser_was_opened = True
def xtf_browser_opened_to_false(self):
"""
Slot. Sets a flag to false to eventually ask a user whether to overwrite a file.
"""
self.xtf_browser_was_opened = False
self.clear_messages()
class DialogExportData(QDialog, DIALOG_UI):
ValidExtensions = ['xtf', 'itf', 'gml', 'xml']
current_row_schema = 0
def __init__(self, iface, qgis_utils, conn_manager):
QDialog.__init__(self)
self.setupUi(self)
QgsGui.instance().enableAutoGeometryRestore(self)
self.iface = iface
self.conn_manager = conn_manager
self.db = self.conn_manager.get_db_connector_from_source()
self.qgis_utils = qgis_utils
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self.ilicache.refresh()
self._conf_db = ConfigDbSupported()
self._params = None
self._current_db = None
self.xtf_file_browse_button.clicked.connect(
make_save_file_selector(
self.xtf_file_line_edit,
title=QCoreApplication.translate("DialogExportData",
"Save in XTF Transfer File"),
file_filter=QCoreApplication.translate(
"DialogExportData",
"XTF Transfer File (*.xtf);;Interlis 1 Transfer File (*.itf);;XML (*.xml);;GML (*.gml)"
),
extension='.xtf',
extensions=['.' + ext for ext in self.ValidExtensions]))
self.xtf_file_browse_button.clicked.connect(
self.xtf_browser_opened_to_true)
self.xtf_browser_was_opened = False
self.validators = Validators()
fileValidator = FileValidator(
pattern=['*.' + ext for ext in self.ValidExtensions],
allow_non_existing=True)
self.xtf_file_line_edit.setPlaceholderText(
QCoreApplication.translate("DialogExportData",
"[Name of the XTF to be created]"))
self.xtf_file_line_edit.setValidator(fileValidator)
self.xtf_file_line_edit.textChanged.connect(
self.validators.validate_line_edits)
self.xtf_file_line_edit.textChanged.connect(
self.xtf_browser_opened_to_false)
self.xtf_file_line_edit.textChanged.emit(
self.xtf_file_line_edit.text())
self.connection_setting_button.clicked.connect(self.show_settings)
self.connection_setting_button.setText(
QCoreApplication.translate("DialogExportData",
"Connection Settings"))
# LOG
self.log_config.setTitle(
QCoreApplication.translate("DialogExportData", "Show log"))
self.log_config.setFlat(True)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.buttonBox.accepted.disconnect()
self.buttonBox.accepted.connect(self.accepted)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self._accept_button = self.buttonBox.addButton(
QCoreApplication.translate("DialogExportData", "Export data"),
QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
self.update_connection_info()
self.update_model_names()
self.restore_configuration()
def update_connection_info(self):
db_description = self.db.get_description_conn_string()
if db_description:
self.db_connect_label.setText(db_description)
self.db_connect_label.setToolTip(self.db.get_display_conn_string())
self._accept_button.setEnabled(True)
else:
self.db_connect_label.setText(
QCoreApplication.translate("DialogExportData",
"The database is not defined!"))
self.db_connect_label.setToolTip('')
self._accept_button.setEnabled(False)
def update_model_names(self):
self.export_models_qmodel = QStandardItemModel()
db_models = None
db_models = self.db.get_models()
if db_models:
for db_model in db_models:
regex = re.compile(r'(?:\{[^\}]*\}|\s)')
for modelname in regex.split(db_model['modelname']):
if modelname and modelname not in DEFAULT_HIDDEN_MODELS:
item = QStandardItem(modelname.strip())
item.setCheckable(False)
item.setEditable(False)
self.export_models_qmodel.appendRow(item)
self.export_models_list_view.setModel(self.export_models_qmodel)
def get_ili_models(self):
ili_models = list()
for index in range(self.export_models_qmodel.rowCount()):
item = self.export_models_qmodel.item(index)
ili_models.append(item.text())
return ili_models
def show_settings(self):
dlg = SettingsDialog(qgis_utils=self.qgis_utils,
conn_manager=self.conn_manager)
# Connect signals (DBUtils, QgisUtils)
dlg.db_connection_changed.connect(
self.conn_manager.db_connection_changed)
dlg.db_connection_changed.connect(
self.qgis_utils.cache_layers_and_relations)
dlg.organization_tools_changed.connect(
self.qgis_utils.organization_tools_changed)
dlg.set_action_type(EnumDbActionType.EXPORT)
dlg.tabWidget.setCurrentIndex(SETTINGS_CONNECTION_TAB_INDEX)
if dlg.exec_():
self.db = dlg.get_db_connection()
self.update_model_names()
self.update_connection_info()
def accepted(self):
configuration = self.update_configuration()
if not self.xtf_file_line_edit.validator().validate(
configuration.xtffile, 0)[0] == QValidator.Acceptable:
message_error = QCoreApplication.translate(
"DialogExportData",
"Please set a valid XTF file before exporting data.")
self.txtStdout.setText(message_error)
self.show_message(message_error, Qgis.Warning)
self.xtf_file_line_edit.setFocus()
return
if not self.get_ili_models():
message_error = QCoreApplication.translate(
"DialogExportData",
"Please set a valid schema to export. This schema does not have information to export."
)
self.txtStdout.setText(message_error)
self.show_message(message_error, Qgis.Warning)
self.export_models_list_view.setFocus()
return
if not configuration.iliexportmodels:
message_error = QCoreApplication.translate(
"DialogExportData",
"Please set a model before exporting data.")
self.txtStdout.setText(message_error)
self.show_message(message_error, Qgis.Warning)
self.export_models_list_view.setFocus()
return
# If xtf browser was opened and the file exists, the user already chose
# to overwrite the file
if os.path.isfile(self.xtf_file_line_edit.text().strip()
) and not self.xtf_browser_was_opened:
self.msg = QMessageBox()
self.msg.setIcon(QMessageBox.Warning)
self.msg.setText(
QCoreApplication.translate(
"DialogExportData",
"{filename} already exists.\nDo you want to replace it?").
format(filename=os.path.basename(
self.xtf_file_line_edit.text().strip())))
self.msg.setWindowTitle(
QCoreApplication.translate("DialogExportData",
"Save in XTF Transfer File"))
self.msg.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
msg_box = self.msg.exec_()
if msg_box == QMessageBox.No:
return
with OverrideCursor(Qt.WaitCursor):
self.progress_bar.show()
self.progress_bar.setValue(0)
self.disable()
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
exporter = iliexporter.Exporter()
item_db = self._conf_db.get_db_items()[self.db.mode]
exporter.tool = item_db.get_mbaker_db_ili_mode()
exporter.configuration = configuration
self.save_configuration(configuration)
exporter.stdout.connect(self.print_info)
exporter.stderr.connect(self.on_stderr)
exporter.process_started.connect(self.on_process_started)
exporter.process_finished.connect(self.on_process_finished)
self.progress_bar.setValue(25)
try:
if exporter.run() != iliexporter.Exporter.SUCCESS:
self.enable()
self.progress_bar.hide()
self.show_message(
QCoreApplication.translate(
"DialogExportData",
"An error occurred when exporting the data. For more information see the log..."
), Qgis.Warning)
return
except JavaNotFoundError:
# Set JAVA PATH
get_java_path_dlg = GetJavaPathDialog()
get_java_path_dlg.setModal(True)
if get_java_path_dlg.exec_():
configuration = self.update_configuration()
if not get_java_path_from_qgis_model_baker():
message_error_java = QCoreApplication.translate(
"DialogExportData",
"""Java could not be found. You can configure the JAVA_HOME environment variable, restart QGIS and try again."""
)
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
self.txtStdout.setText(message_error_java)
self.show_message(message_error_java, Qgis.Warning)
self.enable()
self.progress_bar.hide()
return
self.buttonBox.clear()
self.buttonBox.setEnabled(True)
self.buttonBox.addButton(QDialogButtonBox.Close)
self.progress_bar.setValue(100)
self.show_message(
QCoreApplication.translate(
"DialogExportData",
"Export of the data was successfully completed."),
Qgis.Success)
def save_configuration(self, configuration):
settings = QSettings()
settings.setValue(
'Asistente-LADM_COL/QgisModelBaker/ili2pg/xtffile_export',
configuration.xtffile)
settings.setValue('Asistente-LADM_COL/QgisModelBaker/show_log',
not self.log_config.isCollapsed())
def restore_configuration(self):
settings = QSettings()
self.xtf_file_line_edit.setText(
settings.value(
'Asistente-LADM_COL/QgisModelBaker/ili2pg/xtffile_export'))
# Show log
value_show_log = settings.value(
'Asistente-LADM_COL/QgisModelBaker/show_log', False, type=bool)
self.log_config.setCollapsed(not value_show_log)
# set model repository
# if there is no option by default use online model repository
custom_model_is_checked = settings.value(
'Asistente-LADM_COL/models/custom_model_directories_is_checked',
type=bool)
if custom_model_is_checked:
self.custom_model_directories = settings.value(
'Asistente-LADM_COL/models/custom_models')
def update_configuration(self):
"""
Get the configuration that is updated with the user configuration changes on the dialog.
:return: Configuration
"""
item_db = self._conf_db.get_db_items()[self.db.mode]
configuration = ExportConfiguration()
item_db.set_db_configuration_params(self.db.dict_conn_params,
configuration)
configuration.xtffile = self.xtf_file_line_edit.text().strip()
java_path = get_java_path_from_qgis_model_baker()
if java_path:
self.base_configuration.java_path = java_path
# Check custom model directories
if QSettings().value(
'Asistente-LADM_COL/models/custom_model_directories_is_checked',
type=bool):
if self.custom_model_directories is None:
self.base_configuration.custom_model_directories_enabled = False
else:
self.base_configuration.custom_model_directories = self.custom_model_directories
self.base_configuration.custom_model_directories_enabled = True
configuration.base_configuration = self.base_configuration
if self.get_ili_models():
configuration.iliexportmodels = ';'.join(self.get_ili_models())
configuration.ilimodels = ';'.join(self.get_ili_models())
configuration.disable_validation = not QSettings().value(
'Asistente-LADM_COL/advanced_settings/validate_data_importing_exporting',
True, bool)
return configuration
def print_info(self, text, text_color='#000000', clear=False):
self.txtStdout.setTextColor(QColor(text_color))
self.txtStdout.append(text)
QCoreApplication.processEvents()
def on_stderr(self, text):
color_log_text(text, self.txtStdout)
self.advance_progress_bar_by_text(text)
def on_process_started(self, command):
self.disable()
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
self.txtStdout.setText(command)
QCoreApplication.processEvents()
def on_process_finished(self, exit_code, result):
color = '#004905' if exit_code == 0 else '#aa2222'
self.txtStdout.setTextColor(QColor(color))
self.txtStdout.append(
QCoreApplication.translate("DialogExportData",
"Finished ({})").format(exit_code))
if result == iliexporter.Exporter.SUCCESS:
self.buttonBox.clear()
self.buttonBox.setEnabled(True)
self.buttonBox.addButton(QDialogButtonBox.Close)
else:
self.enable()
# Open log
if self.log_config.isCollapsed():
self.log_config.setCollapsed(False)
def advance_progress_bar_by_text(self, text):
if text.strip() == 'Info: compile models...':
self.progress_bar.setValue(50)
QCoreApplication.processEvents()
elif text.strip() == 'Info: process data...':
self.progress_bar.setValue(55)
QCoreApplication.processEvents()
elif text.strip() == 'Info: first validation pass...':
self.progress_bar.setValue(70)
QCoreApplication.processEvents()
elif text.strip() == 'Info: second validation pass...':
self.progress_bar.setValue(85)
QCoreApplication.processEvents()
def show_help(self):
self.qgis_utils.show_help("export_data")
def disable(self):
self.db_config.setEnabled(False)
self.ili_config.setEnabled(False)
self.buttonBox.setEnabled(False)
def enable(self):
self.db_config.setEnabled(True)
self.ili_config.setEnabled(True)
self.buttonBox.setEnabled(True)
def show_message(self, message, level):
self.bar.pushMessage("Asistente LADM_COL", message, level, duration=0)
def xtf_browser_opened_to_true(self):
"""
Slot. Sets a flag to true to eventually avoid asking a user whether to overwrite a file.
"""
self.xtf_browser_was_opened = True
def xtf_browser_opened_to_false(self):
"""
Slot. Sets a flag to false to eventually ask a user whether to overwrite a file.
"""
self.xtf_browser_was_opened = False
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 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 UploadOverview(uicls_log, basecls_log):
"""Upload status overview dialog."""
MAX_SCHEMATISATION_MODELS = 3
def __init__(self, plugin_dock, parent=None):
super().__init__(parent)
self.setupUi(self)
self.plugin_dock = plugin_dock
self.threedi_api = self.plugin_dock.threedi_api
self.tc = ThreediCalls(self.plugin_dock.threedi_api)
self.communication = self.plugin_dock.communication
self.feedback_logger = ListViewLogger(self.lv_upload_feedback)
self.upload_thread_pool = QThreadPool()
self.ended_tasks = OrderedDict()
self.upload_progresses = defaultdict(lambda: ("NO TASK", 0.0, 0.0))
self.current_upload_row = 0
self.schematisation = None
self.schematisation_sqlite = None
self.schematisation_id = None
self.pb_new_upload.clicked.connect(self.upload_new_model)
self.pb_hide.clicked.connect(self.close)
self.tv_model = None
self.setup_view_model()
self.adjustSize()
@property
def current_local_schematisation(self):
"""Return currently loaded local schematisation."""
return self.plugin_dock.current_local_schematisation
def setup_view_model(self):
"""Setting up model and columns for TreeView."""
nr_of_columns = 4
self.tv_model = QStandardItemModel(0, nr_of_columns - 1)
self.tv_model.setHorizontalHeaderLabels(["Schematisation name", "Revision", "Commit message", "Status"])
self.tv_uploads.setModel(self.tv_model)
self.tv_uploads.selectionModel().selectionChanged.connect(self.on_upload_context_change)
for i in range(nr_of_columns):
self.tv_uploads.resizeColumnToContents(i)
self.progress_widget.hide()
self.label_success.hide()
self.label_failure.hide()
def on_upload_context_change(self):
"""Updating progress bars based on upload selection change."""
selected_indexes = self.tv_uploads.selectedIndexes()
if selected_indexes:
current_index = selected_indexes[0]
current_row = current_index.row()
self.current_upload_row = current_row + 1
self.on_update_upload_progress(self.current_upload_row, *self.upload_progresses[self.current_upload_row])
self.feedback_logger.clear()
try:
for msg, success in self.ended_tasks[self.current_upload_row]:
if success:
self.feedback_logger.log_info(msg)
else:
self.feedback_logger.log_error(msg)
except KeyError:
pass
status_item = self.tv_model.item(current_row, 3)
status = status_item.text()
if status == UploadStatus.SUCCESS.value:
self.progress_widget.hide()
self.label_success.show()
self.label_failure.hide()
elif status == UploadStatus.FAILURE.value:
self.progress_widget.hide()
self.label_success.hide()
self.label_failure.show()
else:
self.progress_widget.show()
self.label_success.hide()
self.label_failure.hide()
def add_upload_to_model(self, upload_specification):
"""Initializing a new upload."""
create_revision = upload_specification["create_revision"]
schematisation = upload_specification["schematisation"]
schema_name_item = QStandardItem(f"{schematisation.name}")
revision = upload_specification["latest_revision"]
revision_number = revision.number + 1 if create_revision is True else revision.number
revision_item = QStandardItem(f"{revision_number}")
commit_msg_item = QStandardItem(f"{upload_specification['commit_message']}")
status_item = QStandardItem(UploadStatus.IN_PROGRESS.value)
self.tv_model.appendRow([schema_name_item, revision_item, commit_msg_item, status_item])
upload_row_number = self.tv_model.rowCount()
upload_row_idx = self.tv_model.index(upload_row_number - 1, 0)
self.tv_uploads.selectionModel().setCurrentIndex(upload_row_idx, QItemSelectionModel.ClearAndSelect)
worker = UploadProgressWorker(
self.threedi_api, self.current_local_schematisation, upload_specification, upload_row_number
)
worker.signals.upload_progress.connect(self.on_update_upload_progress)
worker.signals.thread_finished.connect(self.on_upload_finished_success)
worker.signals.upload_failed.connect(self.on_upload_failed)
worker.signals.revision_committed.connect(self.on_revision_committed)
self.upload_thread_pool.start(worker)
def upload_new_model(self):
"""Initializing new upload wizard."""
if not self.current_local_schematisation or not self.current_local_schematisation.sqlite:
warn_msg = "Please load the schematisation first before starting the upload."
self.communication.show_warn(warn_msg, parent=self)
self.plugin_dock.build_options.load_local_schematisation()
return
self.schematisation_sqlite = self.current_local_schematisation.sqlite
schema_sqlite_loaded = is_toolbox_spatialite_loaded(self.schematisation_sqlite)
if schema_sqlite_loaded is False:
title = "Warning"
question = (
"Warning: the Spatialite that you loaded with the 3Di Toolbox is not in the revision you are "
"about to upload. Do you want to continue?"
)
on_continue_answer = self.communication.ask(self, title, question, QMessageBox.Warning)
if on_continue_answer is not True:
return
self.schematisation_id = self.current_local_schematisation.id
self.schematisation = self.tc.fetch_schematisation(self.schematisation_id)
current_wip_revision = self.current_local_schematisation.wip_revision
latest_revision = (
self.tc.fetch_schematisation_latest_revision(self.schematisation_id)
if current_wip_revision.number > 0
else None
)
latest_revision_number = latest_revision.number if latest_revision else 0
if latest_revision_number != current_wip_revision.number:
question = f"WIP revision number different than latest online revision ({latest_revision_number})"
answer = self.communication.custom_ask(self, "Pick action", question, "Upload anyway?", "Cancel")
if answer == "Cancel":
return
upload_wizard_dialog = UploadWizard(self.plugin_dock, self)
upload_wizard_dialog.exec_()
new_upload = upload_wizard_dialog.new_upload
if not new_upload:
return
if not new_upload["upload_only"]:
deletion_dlg = ModelDeletionDialog(self.plugin_dock, self)
if len(deletion_dlg.threedi_models) >= self.MAX_SCHEMATISATION_MODELS:
deletion_dlg.exec_()
if len(deletion_dlg.threedi_models) >= self.MAX_SCHEMATISATION_MODELS:
self.communication.bar_warn("Uploading canceled...")
return
self.add_upload_to_model(new_upload)
def on_revision_committed(self):
"""Handling actions on successful revision commit."""
self.plugin_dock.update_schematisation_view()
def on_update_upload_progress(self, upload_row_number, task_name, task_progress, total_progress):
"""Handling actions on upload progress update."""
self.upload_progresses[upload_row_number] = (task_name, task_progress, total_progress)
if self.current_upload_row == upload_row_number:
self.lbl_current_task.setText(task_name)
self.pbar_current_task.setValue(task_progress)
self.pbar_total_upload.setValue(total_progress)
if task_progress == 100.0 and task_name != "DONE":
success = True
enriched_success_message = f"{task_name} ==> done"
ended_task_row = (enriched_success_message, success)
if upload_row_number not in self.ended_tasks:
self.ended_tasks[upload_row_number] = [ended_task_row]
else:
upload_ended_tasks = self.ended_tasks[upload_row_number]
if ended_task_row not in upload_ended_tasks:
upload_ended_tasks.append(ended_task_row)
else:
return
self.feedback_logger.log_info(enriched_success_message)
def on_upload_finished_success(self, upload_row_number, msg):
"""Handling action on upload success."""
item = self.tv_model.item(upload_row_number - 1, 3)
item.setText(UploadStatus.SUCCESS.value)
self.plugin_dock.communication.bar_info(msg, log_text_color=Qt.darkGreen)
self.on_upload_context_change()
def on_upload_failed(self, upload_row_number, error_message):
"""Handling action on upload failure."""
item = self.tv_model.item(upload_row_number - 1, 3)
item.setText(UploadStatus.FAILURE.value)
self.plugin_dock.communication.bar_error(error_message, log_text_color=Qt.red)
success = False
failed_task_name = self.upload_progresses[self.current_upload_row][0]
enriched_error_message = f"{failed_task_name} ==> failed\n{error_message}"
failed_task_row = (enriched_error_message, success)
if upload_row_number not in self.ended_tasks:
self.ended_tasks[upload_row_number] = [failed_task_row]
else:
self.ended_tasks[upload_row_number].append(failed_task_row)
self.feedback_logger.log_error(enriched_error_message)
self.on_upload_context_change()
class DialogExportData(QDialog, DIALOG_UI):
ValidExtensions = ['xtf', 'itf', 'gml', 'xml']
current_row_schema = 0
def __init__(self, iface, db, qgis_utils):
QDialog.__init__(self)
self.setupUi(self)
QgsGui.instance().enableAutoGeometryRestore(self)
self.iface = iface
self.db = db
self.qgis_utils = qgis_utils
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self.ilicache.refresh()
self.type_combo_box.clear()
self.type_combo_box.addItem(
QCoreApplication.translate("DialogExportData",
"PostgreSQL/PostGIS"), 'pg')
self.type_combo_box.addItem(
QCoreApplication.translate("DialogExportData", "GeoPackage"),
'gpkg')
self.type_combo_box.currentIndexChanged.connect(self.type_changed)
self.type_changed()
self.xtf_file_browse_button.clicked.connect(
make_save_file_selector(
self.xtf_file_line_edit,
title=QCoreApplication.translate("DialogExportData",
"Save in XTF Transfer File"),
file_filter=QCoreApplication.translate(
"DialogExportData",
"XTF Transfer File (*.xtf);;Interlis 1 Transfer File (*.itf);;XML (*.xml);;GML (*.gml)"
),
extension='.xtf',
extensions=['.' + ext for ext in self.ValidExtensions]))
self.xtf_file_browse_button.clicked.connect(
self.xtf_browser_opened_to_true)
self.xtf_browser_was_opened = False
self.validators = Validators()
fileValidator = FileValidator(
pattern=['*.' + ext for ext in self.ValidExtensions],
allow_non_existing=True)
self.xtf_file_line_edit.setPlaceholderText(
QCoreApplication.translate("DialogExportData",
"[Name of the XTF to be created]"))
self.xtf_file_line_edit.setValidator(fileValidator)
self.xtf_file_line_edit.textChanged.connect(
self.validators.validate_line_edits)
self.xtf_file_line_edit.textChanged.connect(
self.xtf_browser_opened_to_false)
self.xtf_file_line_edit.textChanged.emit(
self.xtf_file_line_edit.text())
# PG
self.db_connect_label.setToolTip(self.db.get_display_conn_string())
self.db_connect_label.setText(self.db.dict_conn_params["database"])
self.connection_setting_button.clicked.connect(self.show_settings)
self.connection_setting_button.setText(
QCoreApplication.translate("DialogExportData",
"Connection Settings"))
# GPKG
self.gpkg_file_line_edit.setPlaceholderText(
QCoreApplication.translate(
"DialogExportData", "[Name of the Geopackage to be created]"))
self.gpkg_file_browse_button.clicked.connect(
make_file_selector(self.gpkg_file_line_edit,
title=QCoreApplication.translate(
"DialogExportData",
"Open GeoPackage database file"),
file_filter=QCoreApplication.translate(
"DialogExportData",
"GeoPackage Database (*.gpkg)")))
gpkgFileValidator = FileValidator(pattern='*.gpkg')
self.gpkg_file_line_edit.setValidator(gpkgFileValidator)
self.gpkg_file_line_edit.textChanged.connect(
self.validators.validate_line_edits)
self.gpkg_file_line_edit.textChanged.emit(
self.gpkg_file_line_edit.text())
# LOG
self.log_config.setTitle(
QCoreApplication.translate("DialogExportData", "Show log"))
self.log_config.setFlat(True)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.buttonBox.accepted.disconnect()
self.buttonBox.accepted.connect(self.accepted)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self.buttonBox.addButton(
QCoreApplication.translate("DialogExportData", "Export data"),
QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
def showEvent(self, event):
# update after create dialog
self.update_schema_names_model()
self.update_model_names(self.get_checked_schema())
self.restore_configuration()
def update_schema_names_model(self):
res, msg = self.db.test_connection()
schema_names = self.db._schema_names_list()
if schema_names:
for schema_name in schema_names:
item = QListWidgetItem(schema_name['schema_name'])
item.setFlags(item.flags() | QtCore.Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Unchecked)
self.schema_names_list_widget.addItem(item)
default_item = self.schema_names_list_widget.item(0)
default_item.setCheckState(Qt.Checked)
else:
self.schema_names_list_widget.clear()
self.export_models_list_view.setModel(QStandardItemModel())
message_error = 'There are no schemes to export into the database. Please select another database.'
self.txtStdout.setText(
QCoreApplication.translate("DialogExportData", message_error))
self.show_message(message_error, Qgis.Warning)
self.schema_names_list_widget.currentRowChanged.connect(
self.on_current_row_changed_schema_names)
self.schema_names_list_widget.itemChanged.connect(
self.on_itemchanged_schema_name)
def on_itemchanged_schema_name(self, selected_item):
# disconnect signal to do changes in the items
self.schema_names_list_widget.itemChanged.disconnect(
self.on_itemchanged_schema_name)
for index in range(self.schema_names_list_widget.count()):
item = self.schema_names_list_widget.item(index)
item.setCheckState(Qt.Unchecked)
item.setSelected(False)
if item == selected_item:
select_index = index
item = self.schema_names_list_widget.item(select_index)
item.setCheckState(Qt.Checked)
item.setSelected(True)
# Update list view with models name info
schema_name = item.text()
self.update_model_names(schema_name)
# connect signal to check when the items change
self.schema_names_list_widget.itemChanged.connect(
self.on_itemchanged_schema_name)
def on_current_row_changed_schema_names(self, current_row):
for index in range(self.schema_names_list_widget.count()):
item = self.schema_names_list_widget.item(index)
item.setCheckState(Qt.Unchecked)
item = self.schema_names_list_widget.item(current_row)
if item:
item.setCheckState(Qt.Checked)
# Update list view with models name info
schema_name = item.text()
self.update_model_names(schema_name)
def update_model_names(self, dbschema):
self.export_models_qmodel = QStandardItemModel()
db_models = None
if self.type_combo_box.currentData() == 'gpkg':
db_models = self.db.get_models()
elif self.type_combo_box.currentData() == 'pg':
db_models = self.db.get_models(dbschema) if dbschema else None
if db_models:
for db_model in db_models:
regex = re.compile(r'(?:\{[^\}]*\}|\s)')
for modelname in regex.split(db_model['modelname']):
if modelname and modelname not in DEFAULT_HIDDEN_MODELS:
item = QStandardItem(modelname.strip())
item.setCheckable(False)
item.setEditable(False)
self.export_models_qmodel.appendRow(item)
self.export_models_list_view.setModel(self.export_models_qmodel)
def get_checked_schema(self):
checked_schema = None
for index in range(self.schema_names_list_widget.count()):
item = self.schema_names_list_widget.item(index)
if item.checkState() == Qt.Checked:
checked_schema = item.text()
break
return checked_schema
def get_ili_models(self):
ili_models = list()
for index in range(self.export_models_qmodel.rowCount()):
item = self.export_models_qmodel.item(index)
ili_models.append(item.text())
return ili_models
def show_settings(self):
dlg = self.qgis_utils.get_settings_dialog()
dlg.tabWidget.setCurrentIndex(SETTINGS_CONNECTION_TAB_INDEX)
if dlg.exec_():
self.db = self.qgis_utils.get_db_connection()
self.db_connect_label.setToolTip(self.db.get_display_conn_string())
self.db_connect_label.setText(self.db.dict_conn_params['database'])
self.update_schema_names_model()
def accepted(self):
configuration = self.update_configuration()
if not self.get_checked_schema():
message_error = QCoreApplication.translate(
"DialogExportData",
"You need to select a valid schema where to get the data from."
)
self.txtStdout.setText(message_error)
self.show_message(message_error, Qgis.Warning)
self.connection_setting_button.setFocus()
return
if not self.xtf_file_line_edit.validator().validate(
configuration.xtffile, 0)[0] == QValidator.Acceptable:
message_error = QCoreApplication.translate(
"DialogExportData",
"Please set a valid XTF file before exporting data.")
self.txtStdout.setText(message_error)
self.show_message(message_error, Qgis.Warning)
self.xtf_file_line_edit.setFocus()
return
if not self.get_ili_models():
message_error = QCoreApplication.translate(
"DialogExportData",
"Please set a valid schema to export. This schema does not have information to export."
)
self.txtStdout.setText(message_error)
self.show_message(message_error, Qgis.Warning)
self.export_models_list_view.setFocus()
return
if not configuration.iliexportmodels:
message_error = QCoreApplication.translate(
"DialogExportData",
"Please set a model before exporting data.")
self.txtStdout.setText(message_error)
self.show_message(message_error, Qgis.Warning)
self.export_models_list_view.setFocus()
return
if self.type_combo_box.currentData() == 'gpkg':
if not configuration.dbfile or self.gpkg_file_line_edit.validator(
).validate(configuration.dbfile, 0)[0] != QValidator.Acceptable:
message_error = QCoreApplication.translate(
"DialogExportData",
"Please set an existing database file before creating the project."
)
self.txtStdout.setText(message_error)
self.show_message(message_error, Qgis.Warning)
self.gpkg_file_line_edit.setFocus()
return
# If xtf browser was opened and the file exists, the user already chose
# to overwrite the file
if os.path.isfile(self.xtf_file_line_edit.text().strip()
) and not self.xtf_browser_was_opened:
self.msg = QMessageBox()
self.msg.setIcon(QMessageBox.Warning)
self.msg.setText(
QCoreApplication.translate(
"DialogExportData",
"{filename} already exists.\nDo you want to replace it?").
format(filename=os.path.basename(
self.xtf_file_line_edit.text().strip())))
self.msg.setWindowTitle(
QCoreApplication.translate("DialogExportData",
"Save in XTF Transfer File"))
self.msg.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
msg_box = self.msg.exec_()
if msg_box == QMessageBox.No:
return
with OverrideCursor(Qt.WaitCursor):
self.progress_bar.show()
self.progress_bar.setValue(0)
self.disable()
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
exporter = iliexporter.Exporter()
exporter.tool_name = 'ili2pg' if self.type_combo_box.currentData(
) == 'pg' else 'ili2gpkg'
exporter.configuration = configuration
self.save_configuration(configuration)
exporter.stdout.connect(self.print_info)
exporter.stderr.connect(self.on_stderr)
exporter.process_started.connect(self.on_process_started)
exporter.process_finished.connect(self.on_process_finished)
self.progress_bar.setValue(25)
try:
if exporter.run() != iliexporter.Exporter.SUCCESS:
self.enable()
self.progress_bar.hide()
self.show_message(
QCoreApplication.translate(
"DialogExportData",
"An error occurred when exporting the data. For more information see the log..."
), Qgis.Warning)
return
except JavaNotFoundError:
# Set JAVA PATH
get_java_path_dlg = DialogGetJavaPath()
get_java_path_dlg.setModal(True)
if get_java_path_dlg.exec_():
configuration = self.update_configuration()
if not get_java_path_from_qgis_model_baker():
message_error_java = QCoreApplication.translate(
"DialogExportData",
"""Java could not be found. You can configure the JAVA_HOME environment variable, restart QGIS and try again."""
)
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
self.txtStdout.setText(message_error_java)
self.show_message(message_error_java, Qgis.Warning)
self.enable()
self.progress_bar.hide()
return
self.buttonBox.clear()
self.buttonBox.setEnabled(True)
self.buttonBox.addButton(QDialogButtonBox.Close)
self.progress_bar.setValue(100)
self.show_message(
QCoreApplication.translate(
"DialogExportData",
"Export of the data was successfully completed."),
Qgis.Success)
def save_configuration(self, configuration):
settings = QSettings()
settings.setValue(
'Asistente-LADM_COL/QgisModelBaker/ili2pg/xtffile_export',
configuration.xtffile)
settings.setValue('Asistente-LADM_COL/db_connection_source',
self.type_combo_box.currentData())
settings.setValue('Asistente-LADM_COL/QgisModelBaker/show_log',
not self.log_config.isCollapsed())
if self.type_combo_box.currentData() == 'gpkg':
settings.setValue(
'Asistente-LADM_COL/QgisModelBaker/ili2gpkg/dbfile',
configuration.dbfile)
def restore_configuration(self):
settings = QSettings()
self.xtf_file_line_edit.setText(
settings.value(
'Asistente-LADM_COL/QgisModelBaker/ili2pg/xtffile_export'))
self.type_combo_box.setCurrentIndex(
self.type_combo_box.findData(
settings.value('Asistente-LADM_COL/db_connection_source',
'pg')))
self.type_changed()
# Show log
value_show_log = settings.value(
'Asistente-LADM_COL/QgisModelBaker/show_log', False, type=bool)
self.log_config.setCollapsed(not value_show_log)
# set model repository
# if there is no option by default use online model repository
custom_model_is_checked = settings.value(
'Asistente-LADM_COL/models/custom_model_directories_is_checked',
type=bool)
if custom_model_is_checked:
self.custom_model_directories = settings.value(
'Asistente-LADM_COL/models/custom_models')
def update_configuration(self):
"""
Get the configuration that is updated with the user configuration changes on the dialog.
:return: Configuration
"""
configuration = ExportConfiguration()
if self.type_combo_box.currentData() == 'pg':
# PostgreSQL specific options
configuration.dbhost = self.db.dict_conn_params["host"]
configuration.dbport = self.db.dict_conn_params["port"]
configuration.dbusr = self.db.dict_conn_params["username"]
configuration.database = self.db.dict_conn_params["database"]
configuration.dbschema = self.get_checked_schema()
configuration.dbpwd = self.db.dict_conn_params["password"]
elif self.type_combo_box.currentData() == 'gpkg':
configuration.dbfile = self.db.dict_conn_params["dbfile"]
configuration.xtffile = self.xtf_file_line_edit.text().strip()
java_path = get_java_path_from_qgis_model_baker()
if java_path:
self.base_configuration.java_path = java_path
# Check custom model directories
if QSettings().value(
'Asistente-LADM_COL/models/custom_model_directories_is_checked',
type=bool):
if self.custom_model_directories is None:
self.base_configuration.custom_model_directories_enabled = False
else:
self.base_configuration.custom_model_directories = self.custom_model_directories
self.base_configuration.custom_model_directories_enabled = True
configuration.base_configuration = self.base_configuration
if self.get_ili_models():
configuration.iliexportmodels = ';'.join(self.get_ili_models())
configuration.ilimodels = ';'.join(self.get_ili_models())
return configuration
def print_info(self, text, text_color='#000000', clear=False):
self.txtStdout.setTextColor(QColor(text_color))
self.txtStdout.append(text)
QCoreApplication.processEvents()
def on_stderr(self, text):
color_log_text(text, self.txtStdout)
self.advance_progress_bar_by_text(text)
def on_process_started(self, command):
self.disable()
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
self.txtStdout.setText(command)
QCoreApplication.processEvents()
def on_process_finished(self, exit_code, result):
color = '#004905' if exit_code == 0 else '#aa2222'
self.txtStdout.setTextColor(QColor(color))
self.txtStdout.append(
QCoreApplication.translate("DialogExportData",
"Finished ({})").format(exit_code))
if result == iliexporter.Exporter.SUCCESS:
self.buttonBox.clear()
self.buttonBox.setEnabled(True)
self.buttonBox.addButton(QDialogButtonBox.Close)
else:
self.enable()
def advance_progress_bar_by_text(self, text):
if text.strip() == 'Info: compile models...':
self.progress_bar.setValue(50)
QCoreApplication.processEvents()
elif text.strip() == 'Info: process data...':
self.progress_bar.setValue(55)
QCoreApplication.processEvents()
elif text.strip() == 'Info: first validation pass...':
self.progress_bar.setValue(70)
QCoreApplication.processEvents()
elif text.strip() == 'Info: second validation pass...':
self.progress_bar.setValue(85)
QCoreApplication.processEvents()
def show_help(self):
self.qgis_utils.show_help("export_data")
def disable(self):
self.type_combo_box.setEnabled(False)
self.pg_config.setEnabled(False)
self.ili_config.setEnabled(False)
self.buttonBox.setEnabled(False)
def enable(self):
self.type_combo_box.setEnabled(True)
self.pg_config.setEnabled(True)
self.ili_config.setEnabled(True)
self.buttonBox.setEnabled(True)
def show_message(self, message, level):
self.bar.pushMessage("Asistente LADM_COL", message, level, duration=0)
def type_changed(self):
self.progress_bar.hide()
if self.type_combo_box.currentData() == 'pg':
self.pg_config.show()
self.gpkg_config.hide()
elif self.type_combo_box.currentData() == 'gpkg':
self.pg_config.hide()
self.gpkg_config.show()
def xtf_browser_opened_to_true(self):
"""
Slot. Sets a flag to true to eventually avoid asking a user whether to overwrite a file.
"""
self.xtf_browser_was_opened = True
def xtf_browser_opened_to_false(self):
"""
Slot. Sets a flag to false to eventually ask a user whether to overwrite a file.
"""
self.xtf_browser_was_opened = False
class DialogImportData(QDialog, DIALOG_UI):
def __init__(self, iface, db, qgis_utils):
QDialog.__init__(self)
self.setupUi(self)
QgsGui.instance().enableAutoGeometryRestore(self)
self.iface = iface
self.db = db
self.qgis_utils = qgis_utils
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self.ilicache.refresh()
self._conf_db = ConfigDbSupported()
self._params = None
self._current_db = None
self.xtf_file_browse_button.clicked.connect(
make_file_selector(
self.xtf_file_line_edit,
title=QCoreApplication.translate(
"DialogImportData", 'Open Transfer or Catalog File'),
file_filter=QCoreApplication.translate(
"DialogImportData",
'Transfer File (*.xtf *.itf);;Catalogue File (*.xml *.xls *.xlsx)'
)))
self.validators = Validators()
self.xtf_file_line_edit.setPlaceholderText(
QCoreApplication.translate("DialogImportData",
"[Name of the XTF to be created]"))
fileValidator = FileValidator(pattern=['*.xtf', '*.itf', '*.xml'])
self.xtf_file_line_edit.setValidator(fileValidator)
self.xtf_file_line_edit.textChanged.connect(self.update_import_models)
self.xtf_file_line_edit.textChanged.emit(
self.xtf_file_line_edit.text())
# db
self.connection_setting_button.clicked.connect(self.show_settings)
self.connection_setting_button.setText(
QCoreApplication.translate("DialogImportData",
'Connection Settings'))
# LOG
self.log_config.setTitle(
QCoreApplication.translate("DialogImportData", "Show log"))
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.buttonBox.accepted.disconnect()
self.buttonBox.accepted.connect(self.accepted)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self._accept_button = self.buttonBox.addButton(
QCoreApplication.translate("DialogImportData", "Import data"),
QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
self.update_connection_info()
self.restore_configuration()
def update_connection_info(self):
db_description = self.db.get_description_conn_string()
if db_description:
self.db_connect_label.setText(db_description)
self.db_connect_label.setToolTip(self.db.get_display_conn_string())
self._accept_button.setEnabled(True)
else:
self.db_connect_label.setText(
QCoreApplication.translate("DialogImportData",
"The database is not defined!"))
self.db_connect_label.setToolTip('')
self._accept_button.setEnabled(False)
def update_import_models(self):
message_error = None
if not self.xtf_file_line_edit.text().strip():
color = '#ffd356' # Light orange
self.import_models_qmodel = QStandardItemModel()
self.import_models_list_view.setModel(self.import_models_qmodel)
else:
if os.path.isfile(self.xtf_file_line_edit.text().strip()):
color = '#fff' # White
self.import_models_qmodel = QStandardItemModel()
models_name = self.find_models_xtf(
self.xtf_file_line_edit.text().strip())
for model_name in models_name:
if not model_name in DEFAULT_HIDDEN_MODELS:
item = QStandardItem(model_name)
item.setCheckable(False)
item.setEditable(False)
self.import_models_qmodel.appendRow(item)
if self.import_models_qmodel.rowCount() > 0:
self.import_models_list_view.setModel(
self.import_models_qmodel)
else:
message_error = QCoreApplication.translate(
"DialogImportData",
"No models were found in the XTF. Is it a valid file?")
color = '#ffd356' # Light orange
self.import_models_qmodel = QStandardItemModel()
self.import_models_list_view.setModel(
self.import_models_qmodel)
else:
message_error = QCoreApplication.translate(
"DialogImportData", "Please set a valid XTF file")
color = '#ffd356' # Light orange
self.import_models_qmodel = QStandardItemModel()
self.import_models_list_view.setModel(
self.import_models_qmodel)
self.xtf_file_line_edit.setStyleSheet(
'QLineEdit {{ background-color: {} }}'.format(color))
if message_error:
self.txtStdout.setText(message_error)
self.show_message(message_error, Qgis.Warning)
self.import_models_list_view.setFocus()
return
def find_models_xtf(self, xtf_path):
models_name = list()
pattern = re.compile(r'<MODEL[^>]*>(?P<text>[^<]*)</MODEL>')
with open(xtf_path, 'r') as f:
for txt in pattern.finditer(f.read()):
model_tag = str(txt.group(0))
name = re.findall('NAME="(.*?)"', model_tag, re.IGNORECASE)
models_name.extend(name)
return models_name
def get_ili_models(self):
ili_models = list()
for index in range(self.import_models_qmodel.rowCount()):
item = self.import_models_qmodel.item(index)
ili_models.append(item.text())
return ili_models
def show_settings(self):
dlg = self.qgis_utils.get_settings_dialog()
dlg.set_action_type(EnumDbActionType.IMPORT)
dlg.tabWidget.setCurrentIndex(SETTINGS_CONNECTION_TAB_INDEX)
if dlg.exec_():
self.db = dlg.get_db_connection()
self.update_connection_info()
def accepted(self):
configuration = self.update_configuration()
if not os.path.isfile(self.xtf_file_line_edit.text().strip()):
message_error = 'Please set a valid XTF file before importing data. XTF file does not exist'
self.txtStdout.setText(
QCoreApplication.translate("DialogImportData", message_error))
self.show_message(message_error, Qgis.Warning)
self.xtf_file_line_edit.setFocus()
return
if not self.xtf_file_line_edit.validator().validate(
configuration.xtffile, 0)[0] == QValidator.Acceptable:
message_error = 'Please set a valid XTF before importing data.'
self.txtStdout.setText(
QCoreApplication.translate("DialogImportData", message_error))
self.show_message(message_error, Qgis.Warning)
self.xtf_file_line_edit.setFocus()
return
if not self.get_ili_models():
message_error = QCoreApplication.translate(
"DialogImportData",
"The selected XTF file does not have information according to the LADM-COL model to import."
)
self.txtStdout.setText(message_error)
self.show_message(message_error, Qgis.Warning)
self.import_models_list_view.setFocus()
return
with OverrideCursor(Qt.WaitCursor):
self.progress_bar.show()
self.progress_bar.setValue(0)
self.disable()
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
dataImporter = iliimporter.Importer(dataImport=True)
item_db = self._conf_db.get_db_items()[self.db.mode]
dataImporter.tool_name = item_db.get_model_baker_tool_name()
dataImporter.configuration = configuration
self.save_configuration(configuration)
dataImporter.stdout.connect(self.print_info)
dataImporter.stderr.connect(self.on_stderr)
dataImporter.process_started.connect(self.on_process_started)
dataImporter.process_finished.connect(self.on_process_finished)
self.progress_bar.setValue(25)
try:
if dataImporter.run() != iliimporter.Importer.SUCCESS:
self.enable()
self.progress_bar.hide()
self.show_message(
QCoreApplication.translate(
"DialogImportData",
"An error occurred when importing the data. For more information see the log..."
), Qgis.Warning)
return
except JavaNotFoundError:
# Set JAVA PATH
get_java_path_dlg = DialogGetJavaPath()
get_java_path_dlg.setModal(True)
if get_java_path_dlg.exec_():
configuration = self.update_configuration()
if not get_java_path_from_qgis_model_baker():
message_error_java = QCoreApplication.translate(
"DialogImportData",
"""Java could not be found. You can configure the JAVA_HOME environment variable, restart QGIS and try again."""
)
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
self.txtStdout.setText(message_error_java)
self.show_message(message_error_java, Qgis.Warning)
self.enable()
self.progress_bar.hide()
return
self.buttonBox.clear()
self.buttonBox.setEnabled(True)
self.buttonBox.addButton(QDialogButtonBox.Close)
self.progress_bar.setValue(100)
self.show_message(
QCoreApplication.translate(
"DialogImportData",
"Import of the data was successfully completed"),
Qgis.Success)
def save_configuration(self, configuration):
settings = QSettings()
settings.setValue(
'Asistente-LADM_COL/QgisModelBaker/ili2pg/xtffile_import',
configuration.xtffile)
settings.setValue('Asistente-LADM_COL/QgisModelBaker/show_log',
not self.log_config.isCollapsed())
def restore_configuration(self):
settings = QSettings()
self.xtf_file_line_edit.setText(
settings.value(
'Asistente-LADM_COL/QgisModelBaker/ili2pg/xtffile_import'))
# Show log
value_show_log = settings.value(
'Asistente-LADM_COL/QgisModelBaker/show_log', False, type=bool)
self.log_config.setCollapsed(not value_show_log)
# set model repository
# if there is no option by default use online model repository
self.use_local_models = settings.value(
'Asistente-LADM_COL/models/custom_model_directories_is_checked',
type=bool)
if self.use_local_models:
self.custom_model_directories = settings.value(
'Asistente-LADM_COL/models/custom_models') if settings.value(
'Asistente-LADM_COL/models/custom_models') else None
def update_configuration(self):
"""
Get the configuration that is updated with the user configuration changes on the dialog.
:return: Configuration
"""
item_db = self._conf_db.get_db_items()[self.db.mode]
configuration = ImportDataConfiguration()
item_db.set_db_configuration_params(self.db.dict_conn_params,
configuration)
configuration.xtffile = self.xtf_file_line_edit.text().strip()
configuration.delete_data = False
configuration.epsg = DEFAULT_EPSG
configuration.inheritance = DEFAULT_INHERITANCE
configuration.create_basket_col = CREATE_BASKET_COL
configuration.create_import_tid = CREATE_IMPORT_TID
configuration.stroke_arcs = STROKE_ARCS
java_path = get_java_path_from_qgis_model_baker()
if java_path:
self.base_configuration.java_path = java_path
# Check custom model directories
if self.use_local_models:
if self.custom_model_directories is None:
self.base_configuration.custom_model_directories_enabled = False
else:
self.base_configuration.custom_model_directories = self.custom_model_directories
self.base_configuration.custom_model_directories_enabled = True
configuration.base_configuration = self.base_configuration
if self.get_ili_models():
configuration.ilimodels = ';'.join(self.get_ili_models())
configuration.disable_validation = not QSettings().value(
'Asistente-LADM_COL/advanced_settings/validate_data_importing_exporting',
True, bool)
return configuration
def print_info(self, text, text_color='#000000', clear=False):
self.txtStdout.setTextColor(QColor(text_color))
self.txtStdout.append(text)
QCoreApplication.processEvents()
def on_stderr(self, text):
color_log_text(text, self.txtStdout)
self.advance_progress_bar_by_text(text)
def on_process_started(self, command):
self.disable()
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
self.txtStdout.setText(command)
QCoreApplication.processEvents()
def on_process_finished(self, exit_code, result):
color = '#004905' if exit_code == 0 else '#aa2222'
self.txtStdout.setTextColor(QColor(color))
self.txtStdout.append('Finished ({})'.format(exit_code))
if result == iliimporter.Importer.SUCCESS:
self.buttonBox.clear()
self.buttonBox.setEnabled(True)
self.buttonBox.addButton(QDialogButtonBox.Close)
else:
self.show_message(
QCoreApplication.translate("DialogImportData",
"Error when importing data"),
Qgis.Warning)
self.enable()
# Open log
if self.log_config.isCollapsed():
self.log_config.setCollapsed(False)
def advance_progress_bar_by_text(self, text):
if text.strip() == 'Info: compile models...':
self.progress_bar.setValue(50)
QCoreApplication.processEvents()
elif text.strip() == 'Info: create table structure...':
self.progress_bar.setValue(55)
QCoreApplication.processEvents()
elif text.strip() == 'Info: first validation pass...':
self.progress_bar.setValue(60)
QCoreApplication.processEvents()
elif text.strip() == 'Info: second validation pass...':
self.progress_bar.setValue(80)
QCoreApplication.processEvents()
def show_help(self):
self.qgis_utils.show_help("import_data")
def disable(self):
self.db_config.setEnabled(False)
self.ili_config.setEnabled(False)
self.buttonBox.setEnabled(False)
def enable(self):
self.db_config.setEnabled(True)
self.ili_config.setEnabled(True)
self.buttonBox.setEnabled(True)
def show_message(self, message, level):
self.bar.pushMessage("Asistente LADM_COL", message, level, duration=0)
class DialogImportData(QDialog, DIALOG_UI):
open_dlg_import_schema = pyqtSignal(dict) # dict with key-value params
BUTTON_NAME_IMPORT_DATA = QCoreApplication.translate(
"DialogImportData", "Import data")
BUTTON_NAME_GO_TO_CREATE_STRUCTURE = QCoreApplication.translate(
"DialogImportData", "Go to Create Structure...")
def __init__(self,
iface,
conn_manager,
context,
link_to_import_schema=True,
parent=None):
QDialog.__init__(self, parent)
self.setupUi(self)
QgsGui.instance().enableAutoGeometryRestore(self)
self.iface = iface
self.conn_manager = conn_manager
self.db_source = context.get_db_sources()[0]
self.link_to_import_schema = link_to_import_schema
self.db = self.conn_manager.get_db_connector_from_source(
self.db_source)
self.base_configuration = BaseConfiguration()
self.logger = Logger()
self.app = AppInterface()
self.__ladmcol_models = LADMColModelRegistry()
self.java_dependency = JavaDependency()
self.java_dependency.download_dependency_completed.connect(
self.download_java_complete)
self.java_dependency.download_dependency_progress_changed.connect(
self.download_java_progress_change)
self.ilicache = IliCache(self.base_configuration)
self.ilicache.refresh()
self._dbs_supported = ConfigDBsSupported()
self._running_tool = False
# There may be 1 case where we need to emit a db_connection_changed from the Import Data dialog:
# 1) Connection Settings was opened and the DB conn was changed.
self._db_was_changed = False # To postpone calling refresh gui until we close this dialog instead of settings
# Similarly, we could call a refresh on layers and relations cache in 1 case:
# 1) If the ID dialog was called for the COLLECTED source: opening Connection Settings and changing the DB
# connection.
self._schedule_layers_and_relations_refresh = False
# We need bar definition above calling clear_messages
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.xtf_file_browse_button.clicked.connect(
make_file_selector(
self.xtf_file_line_edit,
title=QCoreApplication.translate(
"DialogImportData", "Open Transfer or Catalog File"),
file_filter=QCoreApplication.translate(
"DialogImportData",
'Transfer File (*.xtf *.itf);;Catalogue File (*.xml *.xls *.xlsx)'
)))
self.validators = Validators()
self.xtf_file_line_edit.setPlaceholderText(
QCoreApplication.translate("DialogImportData",
"[Name of the XTF to be imported]"))
fileValidator = FileValidator(pattern=['*.xtf', '*.itf', '*.xml'])
self.xtf_file_line_edit.setValidator(fileValidator)
self.xtf_file_line_edit.textChanged.connect(self.update_import_models)
self.xtf_file_line_edit.textChanged.emit(
self.xtf_file_line_edit.text())
# db
self.connection_setting_button.clicked.connect(self.show_settings)
self.connection_setting_button.setText(
QCoreApplication.translate("DialogImportData",
"Connection Settings"))
# LOG
self.log_config.setTitle(
QCoreApplication.translate("DialogImportData", "Show log"))
self.buttonBox.accepted.disconnect()
self.buttonBox.clicked.connect(self.accepted_import_data)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self._accept_button = self.buttonBox.addButton(
self.BUTTON_NAME_IMPORT_DATA, QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
self.update_connection_info()
self.restore_configuration()
def accepted_import_data(self, button):
if self.buttonBox.buttonRole(button) == QDialogButtonBox.AcceptRole:
if button.text() == self.BUTTON_NAME_IMPORT_DATA:
self.accepted()
elif button.text() == self.BUTTON_NAME_GO_TO_CREATE_STRUCTURE:
self.close() # Close import data dialog
self.open_dlg_import_schema.emit({
'selected_models':
self.get_ili_models()
}) # Emit signal to open import schema dialog
def reject(self):
if self._running_tool:
QMessageBox.information(
self, QCoreApplication.translate("DialogImportData",
"Warning"),
QCoreApplication.translate(
"DialogImportData",
"The Import Data tool is still running. Please wait until it finishes."
))
else:
self.close_dialog()
def close_dialog(self):
"""
We use this method to be safe when emitting the db_connection_changed, otherwise we could trigger slots that
unload the plugin, destroying dialogs and thus, leading to crashes.
"""
if self._schedule_layers_and_relations_refresh:
self.conn_manager.db_connection_changed.connect(
self.app.core.cache_layers_and_relations)
if self._db_was_changed:
# If the db was changed, it implies it complies with ladm_col, hence the second parameter
self.conn_manager.db_connection_changed.emit(
self.db, True, self.db_source)
if self._schedule_layers_and_relations_refresh:
self.conn_manager.db_connection_changed.disconnect(
self.app.core.cache_layers_and_relations)
self.logger.info(__name__, "Dialog closed.")
self.done(QDialog.Accepted)
def update_connection_info(self):
db_description = self.db.get_description_conn_string()
if db_description:
self.db_connect_label.setText(db_description)
self.db_connect_label.setToolTip(self.db.get_display_conn_string())
self._accept_button.setEnabled(True)
else:
self.db_connect_label.setText(
QCoreApplication.translate("DialogImportData",
"The database is not defined!"))
self.db_connect_label.setToolTip('')
self._accept_button.setEnabled(False)
def update_import_models(self):
self.clear_messages()
error_msg = None
if not self.xtf_file_line_edit.text().strip():
color = '#ffd356' # Light orange
self.import_models_qmodel = QStandardItemModel()
self.import_models_list_view.setModel(self.import_models_qmodel)
else:
if os.path.isfile(self.xtf_file_line_edit.text().strip()):
color = '#fff' # White
self.import_models_qmodel = QStandardItemModel()
model_names = get_models_from_xtf(
self.xtf_file_line_edit.text().strip())
for model in self.__ladmcol_models.supported_models():
if not model.hidden() and model.full_name() in model_names:
item = QStandardItem(model.full_alias())
item.setData(model.full_name(), Qt.UserRole)
item.setCheckable(False)
item.setEditable(False)
self.import_models_qmodel.appendRow(item)
if self.import_models_qmodel.rowCount() > 0:
self.import_models_list_view.setModel(
self.import_models_qmodel)
else:
error_msg = QCoreApplication.translate(
"DialogImportData",
"No models were found in the XTF. Is it a valid file?")
color = '#ffd356' # Light orange
self.import_models_qmodel = QStandardItemModel()
self.import_models_list_view.setModel(
self.import_models_qmodel)
else:
error_msg = QCoreApplication.translate(
"DialogImportData", "Please set a valid XTF file")
color = '#ffd356' # Light orange
self.import_models_qmodel = QStandardItemModel()
self.import_models_list_view.setModel(
self.import_models_qmodel)
self.xtf_file_line_edit.setStyleSheet(
'QLineEdit {{ background-color: {} }}'.format(color))
if error_msg:
self.txtStdout.setText(error_msg)
self.show_message(error_msg, Qgis.Warning)
self.import_models_list_view.setFocus()
return
def get_ili_models(self):
ili_models = list()
for index in range(self.import_models_qmodel.rowCount()):
item = self.import_models_qmodel.item(index)
ili_models.append(item.data(Qt.UserRole))
return ili_models
def show_settings(self):
# We only need those tabs related to Model Baker/ili2db operations
dlg = SettingsDialog(self.conn_manager, parent=self)
dlg.setWindowTitle(
QCoreApplication.translate("DialogImportData",
"Target DB Connection Settings"))
dlg.show_tip(
QCoreApplication.translate(
"DialogImportData",
"Configure where do you want the XTF data to be imported."))
dlg.set_db_source(self.db_source)
dlg.set_tab_pages_list(
[SETTINGS_CONNECTION_TAB_INDEX, SETTINGS_MODELS_TAB_INDEX])
# Connect signals (DBUtils, Core)
dlg.db_connection_changed.connect(self.db_connection_changed)
if self.db_source == COLLECTED_DB_SOURCE:
self._schedule_layers_and_relations_refresh = True
dlg.set_action_type(EnumDbActionType.IMPORT)
if dlg.exec_():
self.db = dlg.get_db_connection()
self.update_connection_info()
def db_connection_changed(self, db, ladm_col_db, db_source):
self._db_was_changed = True
self.clear_messages()
def accepted(self):
self._running_tool = True
self.txtStdout.clear()
self.progress_bar.setValue(0)
self.bar.clearWidgets()
if not os.path.isfile(self.xtf_file_line_edit.text().strip()):
self._running_tool = False
error_msg = QCoreApplication.translate(
"DialogImportData",
"Please set a valid XTF file before importing data. XTF file does not exist."
)
self.txtStdout.setText(error_msg)
self.show_message(error_msg, Qgis.Warning)
self.xtf_file_line_edit.setFocus()
return
java_home_set = self.java_dependency.set_java_home()
if not java_home_set:
message_java = QCoreApplication.translate(
"DialogImportData",
"""Configuring Java {}...""").format(JAVA_REQUIRED_VERSION)
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
self.txtStdout.setText(message_java)
self.java_dependency.get_java_on_demand()
self.disable()
return
configuration = self.update_configuration()
if configuration.disable_validation: # If data validation at import is disabled, we ask for confirmation
self.msg = QMessageBox()
self.msg.setIcon(QMessageBox.Question)
self.msg.setText(
QCoreApplication.translate(
"DialogImportData",
"Are you sure you want to import your data without validation?"
))
self.msg.setWindowTitle(
QCoreApplication.translate("DialogImportData",
"Import XTF without validation?"))
self.msg.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
res = self.msg.exec_()
if res == QMessageBox.No:
self._running_tool = False
return
if not self.xtf_file_line_edit.validator().validate(
configuration.xtffile, 0)[0] == QValidator.Acceptable:
self._running_tool = False
error_msg = QCoreApplication.translate(
"DialogImportData",
"Please set a valid XTF before importing data.")
self.txtStdout.setText(error_msg)
self.show_message(error_msg, Qgis.Warning)
self.xtf_file_line_edit.setFocus()
return
if not self.get_ili_models():
self._running_tool = False
error_msg = QCoreApplication.translate(
"DialogImportData",
"The selected XTF file does not have information according to the LADM-COL model to import."
)
self.txtStdout.setText(error_msg)
self.show_message(error_msg, Qgis.Warning)
self.import_models_list_view.setFocus()
return
# Get list of models present in the XTF file, in the DB and in the list of required models (by the plugin)
ili_models = set([ili_model for ili_model in self.get_ili_models()])
supported_models_in_ili = set([
m.full_name() for m in self.__ladmcol_models.supported_models()
]).intersection(ili_models)
if not supported_models_in_ili:
self._running_tool = False
error_msg = QCoreApplication.translate("DialogImportData",
"The selected XTF file does not have data from any LADM-COL model supported by the LADM-COL Assistant. " \
"Therefore, you cannot import it! These are the models supported:\n\n * {}").format(" \n * ".join([m.full_alias() for m in self.__ladmcol_models.supported_models()]))
self.txtStdout.setText(error_msg)
self.show_message(error_msg, Qgis.Warning)
self.import_models_list_view.setFocus()
return
db_models = set(self.db.get_models())
suggested_models = sorted(ili_models.difference(db_models))
if not ili_models.issubset(db_models):
self._running_tool = False
error_msg = QCoreApplication.translate("DialogImportData",
"IMPORT ERROR: The XTF file to import does not have the same models as the target database schema. " \
"Please create a schema that also includes the following missing modules:\n\n * {}").format(
" \n * ".join(suggested_models))
self.txtStdout.clear()
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.setText(error_msg)
self.show_message(error_msg, Qgis.Warning)
self.xtf_file_line_edit.setFocus()
# button is removed to define order in GUI
for button in self.buttonBox.buttons():
if button.text() == self.BUTTON_NAME_IMPORT_DATA:
self.buttonBox.removeButton(button)
# Check if button was previously added
self.remove_create_structure_button()
if self.link_to_import_schema:
self.buttonBox.addButton(
self.BUTTON_NAME_GO_TO_CREATE_STRUCTURE,
QDialogButtonBox.AcceptRole).setStyleSheet(
"color: #aa2222;")
self.buttonBox.addButton(self.BUTTON_NAME_IMPORT_DATA,
QDialogButtonBox.AcceptRole)
return
with OverrideCursor(Qt.WaitCursor):
self.progress_bar.show()
self.disable()
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
dataImporter = iliimporter.Importer(dataImport=True)
db_factory = self._dbs_supported.get_db_factory(self.db.engine)
dataImporter.tool = db_factory.get_model_baker_db_ili_mode()
dataImporter.configuration = configuration
self.save_configuration(configuration)
dataImporter.stdout.connect(self.print_info)
dataImporter.stderr.connect(self.on_stderr)
dataImporter.process_started.connect(self.on_process_started)
dataImporter.process_finished.connect(self.on_process_finished)
self.progress_bar.setValue(25)
try:
if dataImporter.run() != iliimporter.Importer.SUCCESS:
self._running_tool = False
self.show_message(
QCoreApplication.translate(
"DialogImportData",
"An error occurred when importing the data. For more information see the log..."
), Qgis.Warning)
return
except JavaNotFoundError:
self._running_tool = False
error_msg_java = QCoreApplication.translate(
"DialogImportData",
"Java {} could not be found. You can configure the JAVA_HOME environment variable manually, restart QGIS and try again."
).format(JAVA_REQUIRED_VERSION)
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
self.txtStdout.setText(error_msg_java)
self.show_message(error_msg_java, Qgis.Warning)
return
self._running_tool = False
self.buttonBox.clear()
self.buttonBox.setEnabled(True)
self.buttonBox.addButton(QDialogButtonBox.Close)
self.progress_bar.setValue(100)
self.show_message(
QCoreApplication.translate(
"DialogImportData",
"Import of the data was successfully completed"),
Qgis.Success)
def download_java_complete(self):
self.accepted()
def download_java_progress_change(self, progress):
self.progress_bar.setValue(progress / 2)
if (progress % 20) == 0:
self.txtStdout.append('...')
def remove_create_structure_button(self):
for button in self.buttonBox.buttons():
if button.text() == self.BUTTON_NAME_GO_TO_CREATE_STRUCTURE:
self.buttonBox.removeButton(button)
def save_configuration(self, configuration):
settings = QSettings()
settings.setValue(
'Asistente-LADM-COL/QgisModelBaker/ili2pg/xtffile_import',
configuration.xtffile)
settings.setValue('Asistente-LADM-COL/QgisModelBaker/show_log',
not self.log_config.isCollapsed())
def restore_configuration(self):
settings = QSettings()
self.xtf_file_line_edit.setText(
settings.value(
'Asistente-LADM-COL/QgisModelBaker/ili2pg/xtffile_import'))
# Show log
value_show_log = settings.value(
'Asistente-LADM-COL/QgisModelBaker/show_log', False, type=bool)
self.log_config.setCollapsed(not value_show_log)
# set model repository
# if there is no option by default use online model repository
self.use_local_models = settings.value(
'Asistente-LADM-COL/models/custom_model_directories_is_checked',
DEFAULT_USE_CUSTOM_MODELS,
type=bool)
if self.use_local_models:
self.custom_model_directories = settings.value(
'Asistente-LADM-COL/models/custom_models', DEFAULT_MODELS_DIR)
def update_configuration(self):
"""
Get the configuration that is updated with the user configuration changes on the dialog.
:return: Configuration
"""
db_factory = self._dbs_supported.get_db_factory(self.db.engine)
configuration = ImportDataConfiguration()
db_factory.set_ili2db_configuration_params(self.db.dict_conn_params,
configuration)
configuration.xtffile = self.xtf_file_line_edit.text().strip()
configuration.delete_data = False
configuration.srs_auth = QSettings().value(
'Asistente-LADM-COL/QgisModelBaker/srs_auth', DEFAULT_SRS_AUTH,
str)
configuration.srs_code = QSettings().value(
'Asistente-LADM-COL/QgisModelBaker/srs_code',
int(DEFAULT_SRS_CODE), int)
configuration.inheritance = ILI2DBNames.DEFAULT_INHERITANCE
configuration.create_basket_col = ILI2DBNames.CREATE_BASKET_COL
configuration.create_import_tid = ILI2DBNames.CREATE_IMPORT_TID
configuration.stroke_arcs = ILI2DBNames.STROKE_ARCS
configuration.with_importtid = True
full_java_exe_path = JavaDependency.get_full_java_exe_path()
if full_java_exe_path:
self.base_configuration.java_path = full_java_exe_path
# User could have changed the default values
self.use_local_models = QSettings().value(
'Asistente-LADM-COL/models/custom_model_directories_is_checked',
DEFAULT_USE_CUSTOM_MODELS,
type=bool)
self.custom_model_directories = QSettings().value(
'Asistente-LADM-COL/models/custom_models', DEFAULT_MODELS_DIR)
# Check custom model directories
if self.use_local_models:
if not self.custom_model_directories:
self.base_configuration.custom_model_directories_enabled = False
else:
self.base_configuration.custom_model_directories = self.custom_model_directories
self.base_configuration.custom_model_directories_enabled = True
configuration.base_configuration = self.base_configuration
if self.get_ili_models():
configuration.ilimodels = ';'.join(self.get_ili_models())
configuration.disable_validation = not QSettings().value(
'Asistente-LADM-COL/models/validate_data_importing_exporting',
True, bool)
return configuration
def print_info(self, text, text_color='#000000', clear=False):
self.txtStdout.setTextColor(QColor(text_color))
self.txtStdout.append(text)
QCoreApplication.processEvents()
def on_stderr(self, text):
color_log_text(text, self.txtStdout)
self.advance_progress_bar_by_text(text)
def on_process_started(self, command):
self.disable()
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
self.txtStdout.setText(command)
QCoreApplication.processEvents()
def on_process_finished(self, exit_code, result):
color = '#004905' if exit_code == 0 else '#aa2222'
self.txtStdout.setTextColor(QColor(color))
self.txtStdout.append('Finished ({})'.format(exit_code))
if result == iliimporter.Importer.SUCCESS:
self.buttonBox.clear()
self.buttonBox.setEnabled(True)
self.buttonBox.addButton(QDialogButtonBox.Close)
else:
self.show_message(
QCoreApplication.translate("DialogImportData",
"Error when importing data"),
Qgis.Warning)
# Open log
if self.log_config.isCollapsed():
self.log_config.setCollapsed(False)
def advance_progress_bar_by_text(self, text):
if text.strip() == 'Info: compile models...':
self.progress_bar.setValue(50)
QCoreApplication.processEvents()
elif text.strip() == 'Info: create table structure...':
self.progress_bar.setValue(55)
QCoreApplication.processEvents()
elif text.strip() == 'Info: first validation pass...':
self.progress_bar.setValue(60)
QCoreApplication.processEvents()
elif text.strip() == 'Info: second validation pass...':
self.progress_bar.setValue(80)
QCoreApplication.processEvents()
def clear_messages(self):
self.bar.clearWidgets(
) # Remove previous messages before showing a new one
self.txtStdout.clear() # Clear previous log messages
self.progress_bar.setValue(0) # Initialize progress bar
def show_help(self):
show_plugin_help("import_data")
def disable(self):
self.source_config.setEnabled(False)
self.target_config.setEnabled(False)
self.buttonBox.setEnabled(False)
def enable(self):
self.source_config.setEnabled(True)
self.target_config.setEnabled(True)
self.buttonBox.setEnabled(True)
def show_message(self, message, level):
if level == Qgis.Warning:
self.enable()
self.bar.clearWidgets(
) # Remove previous messages before showing a new one
self.bar.pushMessage("Asistente LADM-COL", message, level, duration=0)
class PosiviewProperties(QgsOptionsDialogBase, Ui_PosiviewPropertiesBase):
'''
GUI class classdocs for the Configuration dialog
'''
applyChanges = pyqtSignal(dict)
def __init__(self, project, parent=None):
'''
Setup dialog widgets with the project properties
'''
super(PosiviewProperties, self).__init__("PosiViewProperties", parent)
self.setupUi(self)
self.groupBox_6.hide()
self.initOptionsBase(False)
self.restoreOptionsBaseUi()
self.comboBoxParser.addItems(PARSERS)
self.comboBoxProviderType.addItems(DEVICE_TYPES)
self.project = project
self.projectProperties = project.properties()
self.mToolButtonLoad.setDefaultAction(self.actionLoadConfiguration)
self.mToolButtonSave.setDefaultAction(self.actionSaveConfiguration)
self.mobileModel = QStringListModel()
self.mobileListModel = QStringListModel()
self.mMobileListView.setModel(self.mobileListModel)
self.mobileProviderModel = QStandardItemModel()
self.mobileProviderModel.setHorizontalHeaderLabels(
('Provider', 'Filter'))
self.mMobileProviderTableView.setModel(self.mobileProviderModel)
self.providerListModel = QStringListModel()
self.mDataProviderListView.setModel(self.providerListModel)
self.comboBoxProviders.setModel(self.providerListModel)
self.setupModelData(self.projectProperties)
self.setupGeneralData(self.projectProperties)
def setupModelData(self, properties):
self.mobileListModel.setStringList(sorted(
properties['Mobiles'].keys()))
self.providerListModel.setStringList(
sorted(properties['Provider'].keys()))
def setupGeneralData(self, properties):
self.lineEditCruise.setText(properties['Mission']['cruise'])
self.lineEditDive.setText(properties['Mission']['dive'])
self.lineEditStation.setText(properties['Mission']['station'])
self.lineEditRecorderPath.setText(properties['RecorderPath'])
self.checkBoxAutoRecording.setChecked(properties['AutoRecord'])
self.spinBoxNotifyDuration.setValue(properties['NotifyDuration'])
self.checkBoxUtcClock.setChecked(properties['ShowUtcClock'])
self.checkBoxWithSuffix.setChecked(properties['DefaultFormat'] & 4)
self.comboBoxDefaultPositionFormat.setCurrentIndex(
(properties['DefaultFormat']) & 3)
def updateGeneralData(self):
self.projectProperties['Mission']['cruise'] = self.lineEditCruise.text(
)
self.projectProperties['Mission']['dive'] = self.lineEditDive.text()
self.projectProperties['Mission'][
'station'] = self.lineEditStation.text()
self.projectProperties[
'RecorderPath'] = self.lineEditRecorderPath.text()
self.projectProperties[
'AutoRecord'] = self.checkBoxAutoRecording.isChecked()
self.projectProperties[
'NotifyDuration'] = self.spinBoxNotifyDuration.value()
self.projectProperties[
'ShowUtcClock'] = self.checkBoxUtcClock.isChecked()
self.projectProperties[
'DefaultFormat'] = self.comboBoxDefaultPositionFormat.currentIndex(
)
if self.checkBoxWithSuffix.isChecked():
self.projectProperties['DefaultFormat'] |= 4
def getColor(self, value):
try:
return QColor.fromRgba(int(value))
except ValueError:
return QColor(value)
@pyqtSlot(QAbstractButton, name='on_buttonBox_clicked')
def onButtonBoxClicked(self, button):
role = self.buttonBox.buttonRole(button)
if role == QDialogButtonBox.ApplyRole or role == QDialogButtonBox.AcceptRole:
self.updateGeneralData()
self.applyChanges.emit(self.projectProperties)
@pyqtSlot(name='on_actionSaveConfiguration_triggered')
def onActionSaveConfigurationTriggered(self):
''' Save the current configuration
'''
fn, __ = QFileDialog.getSaveFileName(None,
'Save PosiView configuration', '',
'Configuration (*.ini *.conf)')
if fn:
if not os.path.splitext(fn)[1]:
fn += u'.conf'
self.project.store(fn)
@pyqtSlot(name='on_actionLoadConfiguration_triggered')
def onActionLoadConfigurationTriggered(self):
''' Load configuration from file
'''
fn, __ = QFileDialog.getOpenFileName(None,
'Save PosiView configuration', '',
'Configuration (*.ini *.conf)')
self.projectProperties = self.project.read(fn)
self.setupModelData(self.projectProperties)
self.setupGeneralData(self.projectProperties)
@pyqtSlot(QModelIndex, name='on_mMobileListView_clicked')
def editMobile(self, index):
''' Populate the widgets with the selected mobiles properties
'''
if index.isValid():
self.populateMobileWidgets(index)
@pyqtSlot(str, name='on_comboBoxMobileType_currentIndexChanged')
def mobileTypeChanged(self, mType):
if mType == 'SHAPE':
self.lineEditMobileShape.setEnabled(True)
else:
self.lineEditMobileShape.setEnabled(False)
@pyqtSlot(QModelIndex, name='on_mMobileListView_activated')
def activated(self, index):
pass
@pyqtSlot(name='on_toolButtonAddMobile_clicked')
def addMobile(self):
self.mobileListModel.insertRow(self.mobileListModel.rowCount())
index = self.mobileListModel.index(self.mobileListModel.rowCount() - 1)
self.lineEditMobileName.setText('NewMobile')
self.mobileListModel.setData(index, 'NewMobile', Qt.DisplayRole)
self.mMobileListView.setCurrentIndex(index)
self.applyMobile()
@pyqtSlot(name='on_pushButtonApplyMobile_clicked')
def applyMobile(self):
index = self.mMobileListView.currentIndex()
if index.isValid() and not self.lineEditMobileName.text() == '':
mobile = dict()
mobile['Name'] = self.lineEditMobileName.text()
mobile['type'] = self.comboBoxMobileType.currentText()
try:
t = eval(self.lineEditMobileShape.text())
if t.__class__ is tuple or t.__class__ is dict:
mobile['shape'] = t
except SyntaxError:
mobile['shape'] = ((0.0, -0.5), (0.3, 0.5), (0.0, 0.2), (-0.5,
0.5))
mobile['length'] = self.doubleSpinBoxMobileLength.value()
mobile['width'] = self.doubleSpinBoxMobileWidth.value()
mobile['defaultIcon'] = self.checkBoxDefaultIcon.isChecked()
mobile['defaultIconFilled'] = self.checkBoxDefIconFilled.isChecked(
)
mobile['offsetX'] = self.doubleSpinBoxXOffset.value()
mobile['offsetY'] = self.doubleSpinBoxYOffset.value()
mobile['zValue'] = self.spinBoxZValue.value()
mobile['color'] = self.mColorButtonMobileColor.color().rgba()
mobile['fillColor'] = self.mColorButtonMobileFillColor.color(
).rgba()
mobile['timeout'] = self.spinBoxMobileTimeout.value() * 1000
mobile['nofixNotify'] = self.spinBoxMobileNotification.value()
mobile['fadeOut'] = self.checkBoxFadeOut.isChecked()
mobile['trackLength'] = self.spinBoxTrackLength.value()
mobile['trackColor'] = self.mColorButtonMobileTrackColor.color(
).rgba()
mobile['showLabel'] = self.checkBoxShowLabel.isChecked()
provs = dict()
for r in range(self.mobileProviderModel.rowCount()):
try:
fil = int(
self.mobileProviderModel.item(r,
1).data(Qt.DisplayRole))
except Exception:
fil = self.mobileProviderModel.item(r,
1).data(Qt.DisplayRole)
if not fil:
fil = None
provs[self.mobileProviderModel.item(r, 0).data(
Qt.DisplayRole)] = fil
mobile['provider'] = provs
currName = self.mobileListModel.data(index, Qt.DisplayRole)
if not currName == mobile['Name']:
del self.projectProperties['Mobiles'][currName]
self.mobileListModel.setData(index, mobile['Name'],
Qt.DisplayRole)
self.projectProperties['Mobiles'][mobile['Name']] = mobile
def populateMobileWidgets(self, index):
mobile = self.projectProperties['Mobiles'][self.mobileListModel.data(
index, Qt.DisplayRole)]
self.lineEditMobileName.setText(mobile.get('Name'))
self.comboBoxMobileType.setCurrentIndex(
self.comboBoxMobileType.findText(
mobile.setdefault('type', 'BOX').upper()))
if mobile['type'] == 'SHAPE':
self.lineEditMobileShape.setText(str(mobile['shape']))
self.lineEditMobileShape.setEnabled(True)
self.doubleSpinBoxXOffset.setEnabled(True)
self.doubleSpinBoxYOffset.setEnabled(True)
else:
self.lineEditMobileShape.setEnabled(False)
self.doubleSpinBoxXOffset.setEnabled(False)
self.doubleSpinBoxYOffset.setEnabled(False)
self.lineEditMobileShape.clear()
self.doubleSpinBoxMobileLength.setValue(mobile.get('length', 20.0))
self.doubleSpinBoxMobileWidth.setValue(mobile.get('width', 5.0))
self.checkBoxDefaultIcon.setChecked(mobile.get('defaultIcon', True))
self.checkBoxDefIconFilled.setChecked(
mobile.get('defaultIconFilled', False))
self.doubleSpinBoxXOffset.setValue(mobile.get('offsetX', 0.0))
self.doubleSpinBoxYOffset.setValue(mobile.get('offsetY', 0.0))
self.spinBoxZValue.setValue(mobile.get('zValue', 100))
self.mColorButtonMobileColor.setColor(
self.getColor(mobile.get('color', 'black')))
self.mColorButtonMobileFillColor.setColor(
self.getColor(mobile.get('fillColor', 'green')))
self.spinBoxMobileTimeout.setValue(mobile.get('timeout', 3000) / 1000)
self.spinBoxMobileNotification.setValue(mobile.get('nofixNotify', 0))
self.checkBoxFadeOut.setChecked(mobile.get('fadeOut', False))
self.spinBoxTrackLength.setValue(mobile.get('trackLength', 100))
self.mColorButtonMobileTrackColor.setColor(
self.getColor(mobile.get('trackColor', 'green')))
self.checkBoxShowLabel.setChecked(mobile.get('showLabel', False))
r = 0
self.mobileProviderModel.removeRows(
0, self.mobileProviderModel.rowCount())
if 'provider' in mobile:
for k, v in list(mobile['provider'].items()):
prov = QStandardItem(k)
val = QStandardItem(str(v))
self.mobileProviderModel.setItem(r, 0, prov)
self.mobileProviderModel.setItem(r, 1, val)
r += 1
@pyqtSlot(name='on_toolButtonRemoveMobile_clicked')
def removeMobile(self):
idx = self.mMobileListView.currentIndex()
if idx.isValid():
self.projectProperties['Mobiles'].pop(
self.mobileListModel.data(idx, Qt.DisplayRole))
self.mobileListModel.removeRows(idx.row(), 1)
idx = self.mMobileListView.currentIndex()
if idx.isValid():
self.populateMobileWidgets(idx)
@pyqtSlot(name='on_toolButtonRefreshMobileProvider_clicked')
def refreshMobileProvider(self):
prov = self.comboBoxProviders.currentText()
if prov == '':
return
fil = None
if self.lineEditProviderFilter.text() != '':
fil = self.lineEditProviderFilter.text()
items = self.mobileProviderModel.findItems(prov, Qt.MatchExactly, 0)
if items:
for item in items:
self.mobileProviderModel.setItem(item.row(), 1,
QStandardItem(fil))
else:
self.mobileProviderModel.appendRow(
[QStandardItem(prov), QStandardItem(fil)])
@pyqtSlot(name='on_toolButtonRemoveMobileProvider_clicked')
def removeMobileProvider(self):
idx = self.mMobileProviderTableView.currentIndex()
if idx.isValid():
self.mobileProviderModel.removeRow(idx.row())
@pyqtSlot(name='on_pushButtonApplyDataProvider_clicked')
def applyDataProvider(self):
index = self.mDataProviderListView.currentIndex()
if index.isValid() and not self.lineEditProviderName.text() == '':
provider = dict()
provider['Name'] = self.lineEditProviderName.text()
provider['DataDeviceType'] = self.comboBoxProviderType.currentText(
)
if provider['DataDeviceType'] in NETWORK_TYPES:
provider['Host'] = self.lineEditProviderHostName.text()
provider['Port'] = self.spinBoxProviderPort.value()
provider['Parser'] = self.comboBoxParser.currentText()
currName = self.providerListModel.data(index, Qt.DisplayRole)
if not currName == provider['Name']:
del self.projectProperties['Provider'][currName]
self.providerListModel.setData(index, provider['Name'],
Qt.DisplayRole)
self.projectProperties['Provider'][provider['Name']] = provider
@pyqtSlot(QModelIndex, name='on_mDataProviderListView_clicked')
def editDataProvider(self, index):
'''
'''
if index.isValid():
self.populateDataProviderWidgets(index)
def populateDataProviderWidgets(self, index):
provider = self.projectProperties['Provider'][
self.providerListModel.data(index, Qt.DisplayRole)]
self.lineEditProviderName.setText(provider.get('Name'))
self.comboBoxProviderType.setCurrentIndex(
self.comboBoxProviderType.findText(
provider.setdefault('DataDeviceType', 'UDP').upper()))
if provider['DataDeviceType'] in NETWORK_TYPES:
self.stackedWidgetDataDevice.setCurrentIndex(0)
self.lineEditProviderHostName.setText(
provider.setdefault('Host', '0.0.0.0'))
self.spinBoxProviderPort.setValue(
int(provider.setdefault('Port', 2000)))
self.comboBoxParser.setCurrentIndex(
self.comboBoxParser.findText(
provider.setdefault('Parser', 'NONE').upper()))
@pyqtSlot(name='on_toolButtonAddDataProvider_clicked')
def addDataProvider(self):
self.providerListModel.insertRow(self.providerListModel.rowCount())
index = self.providerListModel.index(
self.providerListModel.rowCount() - 1)
self.lineEditProviderName.setText('NewDataProvider')
self.providerListModel.setData(index, 'NewDataProvider',
Qt.DisplayRole)
self.mDataProviderListView.setCurrentIndex(index)
self.applyDataProvider()
@pyqtSlot(name='on_toolButtonRemoveDataProvider_clicked')
def removeDataProvider(self):
idx = self.mDataProviderListView.currentIndex()
if idx.isValid():
self.projectProperties['Provider'].pop(
self.providerListModel.data(idx, Qt.DisplayRole))
self.providerListModel.removeRows(idx.row(), 1)
idx = self.mDataProviderListView.currentIndex()
if idx.isValid():
self.populateDataProviderWidgets(idx)
@pyqtSlot(name='on_toolButtonSelectLogPath_clicked')
def selectRecorderPath(self):
path = QFileDialog.getExistingDirectory(
self, self.tr('Select Recorder Path'),
self.lineEditRecorderPath.text(),
QFileDialog.ShowDirsOnly | QFileDialog.DontResolveSymlinks)
if path != '':
self.lineEditRecorderPath.setText(path)
@pyqtSlot(QPoint, name='on_lineEditMobileShape_customContextMenuRequested')
def mobileShapeContextMenu(self, pos):
menu = QMenu(self.lineEditMobileShape)
vesselAction = menu.addAction(self.tr('Vessel'))
rovAction = menu.addAction(self.tr('ROV'))
auvAction = menu.addAction(self.tr('AUV'))
arrowAction = menu.addAction(self.tr('Arrow'))
selectedAction = menu.exec_(self.lineEditMobileShape.mapToGlobal(pos))
if selectedAction == vesselAction:
self.lineEditMobileShape.setText(
u'((0, -0.5), (0.5, -0.3), (0.5, 0.5), (-0.5, 0.5), (-0.5, -0.3))'
)
elif selectedAction == rovAction:
self.lineEditMobileShape.setText(
u'((0.3, -0.5), (0.5, -0.3), (0.5, 0.5), (-0.5, 0.5), (-0.5, -0.3), (-0.3, -0.5))'
)
elif selectedAction == auvAction:
self.lineEditMobileShape.setText(
u'((0, -0.5), (0.4, -0.3), (0.5, -0.3), (0.5, -0.2), (0.4, -0.2), (0.4, 0.3), (0.5, 0.3), (0.5, 0.4), (0.4, 0.4), (0.0, 0.5), \
(-0.4, 0.4), (-0.5, 0.4), (-0.5, 0.3), (-0.4, 0.3), (-0.4, -0.2), (-0.5, -0.2), (-0.5, -0.3), (-0.4, -0.3))'
)
elif selectedAction == arrowAction:
self.lineEditMobileShape.setText(
u'((0, -0.5), (0.5, 0.5), (0, 0), (-0.5, 0.5))')
@pyqtSlot(name='on_buttonBox_helpRequested')
def showHelp(self):
"""Display application help to the user."""
help_file = os.path.join(
os.path.split(os.path.dirname(__file__))[0], 'help', 'index.html')
QDesktopServices.openUrl(QUrl.fromLocalFile(help_file))
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 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 SimulationOverview(uicls, basecls):
"""Dialog with methods for handling running simulations."""
PROGRESS_COLUMN_IDX = 2
def __init__(self, plugin_dock, parent=None):
super().__init__(parent)
self.setupUi(self)
self.plugin_dock = plugin_dock
self.threedi_api = self.plugin_dock.threedi_api
self.user = self.plugin_dock.current_user
self.model_selection_dlg = ModelSelectionDialog(self.plugin_dock,
parent=self)
self.simulation_init_wizard = None
self.simulation_wizard = None
self.simulations_keys = {}
self.last_progresses = {}
self.simulations_without_progress = set()
self.tv_model = None
self.setup_view_model()
self.plugin_dock.simulations_progresses_sentinel.progresses_fetched.connect(
self.update_progress)
self.pb_new_sim.clicked.connect(self.new_wizard_init)
self.pb_stop_sim.clicked.connect(self.stop_simulation)
def setup_view_model(self):
"""Setting up model and columns for TreeView."""
delegate = SimulationProgressDelegate(self.tv_sim_tree)
self.tv_sim_tree.setItemDelegateForColumn(self.PROGRESS_COLUMN_IDX,
delegate)
self.tv_model = QStandardItemModel(0, 3)
self.tv_model.setHorizontalHeaderLabels(
["Simulation name", "User", "Progress"])
self.tv_sim_tree.setModel(self.tv_model)
def add_simulation_to_model(self, simulation, status, progress):
"""Method for adding simulation to the model."""
sim_id = simulation.id
sim_name_item = QStandardItem(f"{simulation.name} ({sim_id})")
sim_name_item.setData(sim_id, Qt.UserRole)
user_item = QStandardItem(simulation.user)
progress_item = QStandardItem()
progress_item.setData((status, progress), PROGRESS_ROLE)
self.tv_model.appendRow([sim_name_item, user_item, progress_item])
self.simulations_keys[sim_id] = simulation
for i in range(self.PROGRESS_COLUMN_IDX):
self.tv_sim_tree.resizeColumnToContents(i)
def update_progress(self, progresses):
"""Updating progress bars in the running simulations list."""
for sim_id, (sim, status, progress) in progresses.items():
status_name = status.name
if status_name not in [
"queued", "starting", "initialized", "postprocessing"
]:
continue
if sim_id not in self.simulations_keys:
self.add_simulation_to_model(sim, status, progress)
row_count = self.tv_model.rowCount()
for row_idx in range(row_count):
name_item = self.tv_model.item(row_idx, 0)
sim_id = name_item.data(Qt.UserRole)
if sim_id in self.simulations_without_progress or sim_id not in progresses:
continue
progress_item = self.tv_model.item(row_idx,
self.PROGRESS_COLUMN_IDX)
sim, new_status, new_progress = progresses[sim_id]
status_name = new_status.name
if status_name == "stopped" or status_name == "crashed":
old_status, old_progress = progress_item.data(PROGRESS_ROLE)
progress_item.setData((new_status, old_progress),
PROGRESS_ROLE)
self.simulations_without_progress.add(sim_id)
else:
progress_item.setData((new_status, new_progress),
PROGRESS_ROLE)
if status_name == "finished":
self.simulations_without_progress.add(sim_id)
msg = f"Simulation {sim.name} finished!"
self.plugin_dock.communication.bar_info(msg,
log_text_color=QColor(
Qt.darkGreen))
def new_wizard_init(self):
"""Open new simulation initiation options dialog."""
if self.plugin_dock.current_local_schematisation is not None:
self.model_selection_dlg.search_le.setText(
self.plugin_dock.current_local_schematisation.name)
self.model_selection_dlg.fetch_3di_models()
self.model_selection_dlg.refresh_templates_list()
self.model_selection_dlg.exec_()
if self.model_selection_dlg.model_is_loaded:
simulation_template = self.model_selection_dlg.current_simulation_template
simulation, settings_overview, events = self.get_simulation_data_from_template(
simulation_template)
self.simulation_init_wizard = SimulationInit(simulation_template,
settings_overview,
events,
parent=self)
self.simulation_init_wizard.exec_()
if self.simulation_init_wizard.open_wizard:
self.new_simulation(simulation, settings_overview, events)
def get_simulation_data_from_template(self, template):
"""Fetching simulation, settings and events data from the simulation template."""
simulation, settings_overview, events = None, None, None
try:
tc = ThreediCalls(self.threedi_api)
simulation = template.simulation
settings_overview = tc.fetch_simulation_settings_overview(
str(simulation.id))
events = tc.fetch_simulation_events(simulation.id)
except ApiException as e:
error_msg = extract_error_message(e)
self.plugin_dock.communication.bar_error(error_msg)
except Exception as e:
error_msg = f"Error: {e}"
self.plugin_dock.communication.bar_error(error_msg)
return simulation, settings_overview, events
def new_simulation(self, simulation, settings_overview, events):
"""Opening a wizard which allows defining and running new simulations."""
self.simulation_wizard = SimulationWizard(self.plugin_dock,
self.model_selection_dlg,
self.simulation_init_wizard)
if simulation:
self.simulation_wizard.load_template_parameters(
simulation, settings_overview, events)
self.close()
self.simulation_wizard.exec_()
new_simulations = self.simulation_wizard.new_simulations
if new_simulations is not None:
for sim in new_simulations:
initial_status = self.simulation_wizard.new_simulation_statuses.get(
sim.id)
initial_progress = Progress(percentage=0, time=sim.duration)
self.add_simulation_to_model(sim, initial_status,
initial_progress)
def stop_simulation(self):
"""Sending request to shut down currently selected simulation."""
index = self.tv_sim_tree.currentIndex()
if not index.isValid():
return
title = "Warning"
question = "This simulation is now running.\nAre you sure you want to stop it?"
answer = self.plugin_dock.communication.ask(self, title, question,
QMessageBox.Warning)
if answer is True:
try:
name_item = self.tv_model.item(index.row(), 0)
sim_id = name_item.data(Qt.UserRole)
tc = ThreediCalls(self.plugin_dock.threedi_api)
tc.create_simulation_action(sim_id, name="shutdown")
msg = f"Simulation {name_item.text()} stopped!"
self.plugin_dock.communication.bar_info(msg)
except ApiException as e:
error_msg = extract_error_message(e)
self.plugin_dock.communication.show_error(error_msg)
except Exception as e:
error_msg = f"Error: {e}"
self.plugin_dock.communication.show_error(error_msg)
class DialListCheckBox(object):
"""
Dialog with list check box
example : 1,2,4,6,8
"""
def __init__(self, values, checked_values=[]):
self.dial = QDialog()
self.result = ""
# Layout Principal
m_vbl = QVBoxLayout(self.dial)
# List item checkable
view = QListView()
m_vbl.addWidget(view)
self.m_sim = QStandardItemModel()
view.setModel(self.m_sim)
self._load_item(values, checked_values)
# List buttons
bt_all = QPushButton(self.tr("All"))
bt_all.clicked.connect(lambda: self._check_all())
bt_nothing = QPushButton(self.tr("Nothing"))
bt_nothing.clicked.connect(lambda: self._check_nothing())
bt_print = QPushButton(self.tr("Ok"))
bt_print.clicked.connect(lambda: self._check_ok())
# Sub layout for buttons
m_vbh = QHBoxLayout()
m_vbl.addLayout(m_vbh)
m_vbh.addWidget(bt_all)
m_vbh.addWidget(bt_nothing)
m_vbh.addWidget(bt_print)
def _load_item(self, values, checked_values):
"""Load item list"""
for v in values:
item = QStandardItem(str(v))
if v in checked_values:
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
item.setCheckable(True)
self.m_sim.appendRow(item)
def _check_all(self):
"""Check all item"""
for index in range(self.m_sim.rowCount(
)): ## Iteration sur le model (contient la list des items)
item = self.m_sim.item(index)
if item.isCheckable() and item.checkState(
) == Qt.Unchecked: # Si Unchecked
item.setCheckState(Qt.Checked)
def _check_nothing(self):
"""Uncheck all item"""
for index in range(self.m_sim.rowCount(
)): ## Iteration sur le model (contient la list des items)
item = self.m_sim.item(index)
if item.isCheckable() and item.checkState(
) == Qt.Checked: # Si Checked
item.setCheckState(Qt.Unchecked)
def _check_ok(self):
"""Get value of checked items and exit"""
l_value = []
for index in range(self.m_sim.rowCount(
)): ## Iteration sur le model (contient la list des items)
item = self.m_sim.item(index)
if item.isCheckable() and item.checkState(
) == Qt.Checked: # Si Checked
l_value.append(str(item.text()))
if l_value:
s_value = ";".join(l_value)
else:
s_value = ""
self.result = s_value
self.dial.close()
def run(self):
self.dial.setWindowTitle(self.tr("Select values"))
self.dial.exec_()
return self.result
def tr(self, string, context=''):
if context == '' or context == None:
context = self.__class__.__name__
return QCoreApplication.translate(context, string)
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 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 SimulationResults(uicls, basecls):
"""Dialog with methods for handling simulations results."""
PROGRESS_COLUMN_IDX = 3
def __init__(self, plugin_dock, parent=None):
super().__init__(parent)
self.setupUi(self)
self.plugin_dock = plugin_dock
self.api_client = self.plugin_dock.threedi_api
self.download_results_thread = None
self.download_worker = None
self.finished_simulations = {}
self.tv_model = None
self.last_progress_item = None
self.setup_view_model()
self.plugin_dock.simulations_progresses_sentinel.progresses_fetched.connect(self.update_finished_list)
self.pb_cancel.clicked.connect(self.close)
self.pb_download.clicked.connect(self.download_results)
self.tv_finished_sim_tree.selectionModel().selectionChanged.connect(self.toggle_download_results)
def setup_view_model(self):
"""Setting up model and columns for TreeView."""
self.tv_model = QStandardItemModel(0, 4)
delegate = DownloadProgressDelegate(self.tv_finished_sim_tree)
self.tv_finished_sim_tree.setItemDelegateForColumn(self.PROGRESS_COLUMN_IDX, delegate)
self.tv_model.setHorizontalHeaderLabels(["Simulation name", "User", "Expires", "Download progress"])
self.tv_finished_sim_tree.setModel(self.tv_model)
def toggle_download_results(self):
"""Toggle download if any simulation is selected."""
if self.download_results_thread is None:
selection_model = self.tv_finished_sim_tree.selectionModel()
if selection_model.hasSelection():
self.pb_download.setEnabled(True)
else:
self.pb_download.setDisabled(True)
def add_finished_simulation_to_model(self, simulation, status):
"""Method for adding simulation to the model."""
sim_id = simulation.id
sim_name_item = QStandardItem(f"{simulation.name} ({sim_id})")
sim_name_item.setData(sim_id, Qt.UserRole)
user_item = QStandardItem(simulation.user)
delta = relativedelta(status.created, ThreediCalls.EXPIRATION_TIME)
expires_item = QStandardItem(f"{delta.days} day(s)")
progress_item = QStandardItem()
progress_item.setData(-1, Qt.UserRole)
self.tv_model.insertRow(0, [sim_name_item, user_item, expires_item, progress_item])
self.finished_simulations[sim_id] = simulation
def update_finished_list(self, progresses):
"""Update finished simulations list."""
for sim_id, (sim, status, progress) in progresses.items():
status_name = status.name
if status_name != "finished":
continue
if sim_id not in self.finished_simulations:
self.add_finished_simulation_to_model(sim, status)
def on_download_progress_update(self, percentage):
"""Update download progress bar."""
self.last_progress_item.setData(percentage, Qt.UserRole)
if percentage == 0:
row = self.last_progress_item.index().row()
name_text = self.tv_model.item(row, 0).text()
msg = f"Downloading results of {name_text} started!"
self.plugin_dock.communication.bar_info(msg)
def on_download_finished_success(self, msg):
"""Reporting finish successfully status and closing download thread."""
self.plugin_dock.communication.bar_info(msg, log_text_color=Qt.darkGreen)
self.download_results_thread.quit()
self.download_results_thread.wait()
self.download_results_thread = None
self.download_worker = None
self.toggle_download_results()
def on_download_finished_failed(self, msg):
"""Reporting failure and closing download thread."""
self.plugin_dock.communication.bar_error(msg, log_text_color=Qt.red)
self.download_results_thread.quit()
self.download_results_thread.wait()
self.download_results_thread = None
self.download_worker = None
self.toggle_download_results()
def terminate_download_thread(self):
"""Forcing termination of download background thread."""
if self.download_results_thread is not None and self.download_results_thread.isRunning():
self.plugin_dock.communication.bar_info("Terminating download thread.")
self.download_results_thread.terminate()
self.plugin_dock.communication.bar_info("Waiting for download thread termination.")
self.download_results_thread.wait()
self.plugin_dock.communication.bar_info("Download worker terminated.")
self.download_results_thread = None
self.download_worker = None
def pick_results_destination_dir(self):
"""Pick folder where results will be written to."""
working_dir = self.plugin_dock.plugin_settings.working_dir
last_folder = QSettings().value("threedi/last_results_folder", working_dir, type=str)
directory = QFileDialog.getExistingDirectory(self, "Select Results Directory", last_folder)
if len(directory) == 0:
return None
QSettings().setValue("threedi/last_results_folder", directory)
return directory
def download_results(self):
"""Download simulation results files."""
current_index = self.tv_finished_sim_tree.currentIndex()
if not current_index.isValid():
return
working_dir = self.plugin_dock.plugin_settings.working_dir
local_schematisations = list_local_schematisations(working_dir)
try:
current_row = current_index.row()
name_item = self.tv_model.item(current_row, 0)
sim_id = name_item.data(Qt.UserRole)
simulation = self.finished_simulations[sim_id]
simulation_name = simulation.name.replace(" ", "_")
simulation_model_id = int(simulation.threedimodel_id)
tc = ThreediCalls(self.plugin_dock.threedi_api)
try:
model_3di = tc.fetch_3di_model(simulation_model_id)
gridadmin_downloads = tc.fetch_3di_model_gridadmin_download(simulation_model_id)
if model_3di.schematisation_id:
model_schematisation_id = model_3di.schematisation_id
model_schematisation_name = model_3di.schematisation_name
model_revision_number = model_3di.revision_number
try:
local_schematisation = local_schematisations[model_schematisation_id]
except KeyError:
local_schematisation = LocalSchematisation(
working_dir, model_schematisation_id, model_schematisation_name, create=True
)
try:
local_revision = local_schematisation.revisions[model_revision_number]
except KeyError:
local_revision = LocalRevision(local_schematisation, model_revision_number)
local_revision.make_revision_structure()
results_dir = local_revision.results_dir
else:
warn_msg = (
"The 3Di model to which these results belong was uploaded with Tortoise and does not "
"belong to any schematisation. Therefore, it cannot be determined to which "
"schematisation the results should be downloaded.\n\nPlease select a directory to save "
"the result files to."
)
self.plugin_dock.communication.show_warn(warn_msg)
results_dir = self.pick_results_destination_dir()
if not results_dir:
self.plugin_dock.communication.show_warn(warn_msg)
return
except ApiException as e:
if e.status == 404:
warn_msg = (
"The 3Di model to which these results belong is owned by an organisation for which "
"you do not have sufficient rights. Therefore, you cannot download the computational "
"grid (gridadmin.h5) and it cannot be determined to which schematisation the results "
"should be downloaded.\n\nContact the servicedesk to obtain access rights to the "
"organisation that owns the 3Di model.\n\nPlease select a directory to save the result"
" files to."
)
self.plugin_dock.communication.show_warn(warn_msg)
results_dir = self.pick_results_destination_dir()
if not results_dir:
return
gridadmin_downloads = None
else:
raise e
simulation_subdirectory = os.path.join(results_dir, f"sim_{sim_id}_{simulation_name}")
downloads = tc.fetch_simulation_downloads(sim_id)
if gridadmin_downloads is not None:
downloads.append(gridadmin_downloads)
downloads.sort(key=lambda x: x[-1].size)
self.last_progress_item = self.tv_model.item(current_row, self.PROGRESS_COLUMN_IDX)
except ApiException as e:
error_msg = extract_error_message(e)
self.plugin_dock.communication.show_error(error_msg)
return
except Exception as e:
error_msg = f"Error: {e}"
self.plugin_dock.communication.show_error(error_msg)
return
self.pb_download.setDisabled(True)
self.download_results_thread = QThread()
self.download_worker = DownloadProgressWorker(simulation, downloads, simulation_subdirectory)
self.download_worker.moveToThread(self.download_results_thread)
self.download_worker.thread_finished.connect(self.on_download_finished_success)
self.download_worker.download_failed.connect(self.on_download_finished_failed)
self.download_worker.download_progress.connect(self.on_download_progress_update)
self.download_results_thread.started.connect(self.download_worker.run)
self.download_results_thread.start()
class MultipleInputDialog(BASE, WIDGET):
def __init__(self, options, selectedoptions=None, datatype=None):
super(MultipleInputDialog, self).__init__(None)
self.setupUi(self)
self.datatype = datatype
self.model = None
self.options = []
for i, option in enumerate(options):
if option is None or isinstance(option, str):
self.options.append((i, option))
else:
self.options.append((option[0], option[1]))
self.selectedoptions = selectedoptions or []
# Additional buttons
self.btnSelectAll = QPushButton(self.tr('Select All'))
self.buttonBox.addButton(self.btnSelectAll,
QDialogButtonBox.ActionRole)
self.btnClearSelection = QPushButton(self.tr('Clear Selection'))
self.buttonBox.addButton(self.btnClearSelection,
QDialogButtonBox.ActionRole)
self.btnToggleSelection = QPushButton(self.tr('Toggle Selection'))
self.buttonBox.addButton(self.btnToggleSelection,
QDialogButtonBox.ActionRole)
if self.datatype is not None:
btnAddFile = QPushButton(
QCoreApplication.translate("MultipleInputDialog",
'Add File(s)…'))
btnAddFile.clicked.connect(self.addFiles)
self.buttonBox.addButton(btnAddFile, QDialogButtonBox.ActionRole)
self.btnSelectAll.clicked.connect(lambda: self.selectAll(True))
self.btnClearSelection.clicked.connect(lambda: self.selectAll(False))
self.btnToggleSelection.clicked.connect(self.toggleSelection)
self.settings = QgsSettings()
self.restoreGeometry(
self.settings.value("/Processing/multipleInputDialogGeometry",
QByteArray()))
self.lstLayers.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.lstLayers.setDragDropMode(QAbstractItemView.InternalMove)
self.populateList()
self.finished.connect(self.saveWindowGeometry)
def saveWindowGeometry(self):
self.settings.setValue("/Processing/multipleInputDialogGeometry",
self.saveGeometry())
def populateList(self):
self.model = QStandardItemModel()
for value, text in self.options:
item = QStandardItem(text)
item.setData(value, Qt.UserRole)
item.setCheckState(Qt.Checked if value in
self.selectedoptions else Qt.Unchecked)
item.setCheckable(True)
item.setDropEnabled(False)
self.model.appendRow(item)
# add extra options (e.g. manually added layers)
for t in [o for o in self.selectedoptions if not isinstance(o, int)]:
if isinstance(t, QgsProcessingModelChildParameterSource):
item = QStandardItem(t.staticValue())
else:
item = QStandardItem(t)
item.setData(item.text(), Qt.UserRole)
item.setCheckState(Qt.Checked)
item.setCheckable(True)
item.setDropEnabled(False)
self.model.appendRow(item)
self.lstLayers.setModel(self.model)
def accept(self):
self.selectedoptions = []
model = self.lstLayers.model()
for i in range(model.rowCount()):
item = model.item(i)
if item.checkState() == Qt.Checked:
self.selectedoptions.append(item.data(Qt.UserRole))
QDialog.accept(self)
def reject(self):
self.selectedoptions = None
QDialog.reject(self)
def getItemsToModify(self):
items = []
if len(self.lstLayers.selectedIndexes()) > 1:
for i in self.lstLayers.selectedIndexes():
items.append(self.model.itemFromIndex(i))
else:
for i in range(self.model.rowCount()):
items.append(self.model.item(i))
return items
def selectAll(self, value):
for item in self.getItemsToModify():
item.setCheckState(Qt.Checked if value else Qt.Unchecked)
def toggleSelection(self):
for item in self.getItemsToModify():
checked = item.checkState() == Qt.Checked
item.setCheckState(Qt.Unchecked if checked else Qt.Checked)
def getFileFilter(self, datatype):
"""
Returns a suitable file filter pattern for the specified parameter definition
:param param:
:return:
"""
if datatype == QgsProcessing.TypeRaster:
return QgsProviderRegistry.instance().fileRasterFilters()
elif datatype == QgsProcessing.TypeFile:
return self.tr('All files (*.*)')
else:
exts = QgsVectorFileWriter.supportedFormatExtensions()
for i in range(len(exts)):
exts[i] = self.tr('{0} files (*.{1})').format(
exts[i].upper(), exts[i].lower())
return self.tr('All files (*.*)') + ';;' + ';;'.join(exts)
def addFiles(self):
filter = self.getFileFilter(self.datatype)
settings = QgsSettings()
path = str(settings.value('/Processing/LastInputPath'))
ret, selected_filter = QFileDialog.getOpenFileNames(
self, self.tr('Select File(s)'), path, filter)
if ret:
files = list(ret)
settings.setValue('/Processing/LastInputPath',
os.path.dirname(str(files[0])))
for filename in files:
item = QStandardItem(filename)
item.setData(filename, Qt.UserRole)
item.setCheckState(Qt.Checked)
item.setCheckable(True)
item.setDropEnabled(False)
self.model.appendRow(item)
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
