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 ResourceSharingDialog(QDialog, FORM_CLASS): TAB_ALL = 0 TAB_INSTALLED = 1 TAB_SETTINGS = 2 def __init__(self, parent=None, iface=None): """Constructor. :param parent: Optional widget to use as parent :type parent: QWidget :param iface: An instance of QGisInterface :type iface: QGisInterface """ super(ResourceSharingDialog, self).__init__(parent) self.setupUi(self) self.iface = iface # Reconfigure UI self.setModal(True) self.button_edit.setEnabled(False) self.button_delete.setEnabled(False) self.button_install.setEnabled(False) self.button_open.setEnabled(False) self.button_uninstall.setEnabled(False) # Set up the "main menu" - QListWidgetItem # All collections icon_all = QIcon() icon_all.addFile(str(resources_path('img', 'plugin.svg')), QSize(), QIcon.Normal, QIcon.Off) item_all = QListWidgetItem() item_all.setIcon(icon_all) item_all.setText(self.tr('All collections')) # Installed collections icon_installed = QIcon() icon_installed.addFile( str(resources_path('img', 'plugin-installed.svg')), QSize(), QIcon.Normal, QIcon.Off) item_installed = QListWidgetItem() item_installed.setIcon(icon_installed) item_installed.setText(self.tr('Installed collections')) item_all.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled) # Settings / repositories icon_settings = QIcon() icon_settings.addFile(str(resources_path('img', 'settings.svg')), QSize(), QIcon.Normal, QIcon.Off) item_settings = QListWidgetItem() item_settings.setIcon(icon_settings) item_settings.setText(self.tr('Settings')) item_all.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled) # Add the items to the list widget self.menu_list_widget.addItem(item_all) self.menu_list_widget.addItem(item_installed) self.menu_list_widget.addItem(item_settings) # Init the message bar self.message_bar = QgsMessageBar(self) self.message_bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed) self.vlayoutRightColumn.insertWidget(0, self.message_bar) # Progress dialog for long running processes self.progress_dialog = None # Init the repository manager dialog self.repository_manager = RepositoryManager() self.collection_manager = CollectionManager() # Collections list view self.collections_model = QStandardItemModel(0, 1) self.collections_model.sort(0, Qt.AscendingOrder) self.collection_proxy = CustomSortFilterProxyModel(self) self.collection_proxy.setSourceModel(self.collections_model) self.list_view_collections.setModel(self.collection_proxy) # Active selected collection self._selected_collection_id = None # Slots self.button_add.clicked.connect(self.add_repository) self.button_edit.clicked.connect(self.edit_repository) self.button_delete.clicked.connect(self.delete_repository) self.button_reload.clicked.connect(self.reload_repositories) self.menu_list_widget.currentRowChanged.connect(self.set_current_tab) self.list_view_collections.selectionModel().currentChanged.connect( self.on_list_view_collections_clicked) self.line_edit_filter.textChanged.connect(self.filter_collections) self.button_install.clicked.connect(self.install_collection) self.button_open.clicked.connect(self.open_collection) self.button_uninstall.clicked.connect(self.uninstall_collection) self.button_box.button(QDialogButtonBox.Help).clicked.connect( self.open_help) # Populate the repositories widget and collections list view self.populate_repositories_widget() self.reload_collections_model() def set_current_tab(self, index): """Set stacked widget based on the active tab. :param index: The index of the active widget (in the list widget). :type index: int """ # Clear message bar self.message_bar.clearWidgets() if index == (self.menu_list_widget.count() - 1): # Last menu entry - Settings self.stacked_menu_widget.setCurrentIndex(1) else: # Not settings, must be Collections (all or installed) if index == 1: # Installed collections self.collection_proxy.accepted_status = \ COLLECTION_INSTALLED_STATUS # Set the web view title = self.tr('Installed Collections') description = self.tr( 'On the left you see the list of all the ' 'installed collections.') else: # All collections (0) self.collection_proxy.accepted_status = COLLECTION_ALL_STATUS # Set the web view title = self.tr('All Collections') description = self.tr( 'On the left you see a list of all the collections ' 'that are available from the registered repositories.<br> ' 'Installed collections are emphasized (in <b>bold</b>).') context = { 'resources_path': str(resources_path()), 'title': title, 'description': description } self.web_view_details.setHtml( render_template('tab_description.html', context)) self.stacked_menu_widget.setCurrentIndex(0) def add_repository(self): """Open add repository dialog.""" dlg = ManageRepositoryDialog(self) if not dlg.exec_(): return for repoName, repo in self.repository_manager.directories.items(): if dlg.line_edit_url.text().strip() == repo['url']: self.message_bar.pushMessage( self.tr( 'Unable to add another repository with the same URL!'), Qgis.Warning, 5) return if dlg.line_edit_name.text().strip() == repoName: self.message_bar.pushMessage( self.tr('Repositories must have unique names!'), Qgis.Warning, 5) return repo_name = dlg.line_edit_name.text() repo_url = dlg.line_edit_url.text().strip() repo_auth_cfg = dlg.line_edit_auth_id.text().strip() if repo_name in self.repository_manager.directories: repo_name += '(2)' # Show progress dialog self.show_progress_dialog("Fetching repository's metadata") # Add repository try: status, adderror = self.repository_manager.add_directory( repo_name, repo_url, repo_auth_cfg) if status: self.message_bar.pushMessage( self.tr('Repository was successfully added'), Qgis.Success, 5) else: self.message_bar.pushMessage( self.tr('Unable to add repository: %s') % adderror, Qgis.Warning, 5) except Exception as e: self.message_bar.pushMessage(self.tr('%s') % e, Qgis.Warning, 5) finally: self.progress_dialog.hide() # Reload data and widget self.reload_data_and_widget() # Deactivate edit and delete button self.button_edit.setEnabled(False) self.button_delete.setEnabled(False) def edit_repository(self): """Open edit repository dialog.""" selected_item = self.tree_repositories.currentItem() if selected_item: repo_name = selected_item.text(0) if not repo_name: return # Check if it is among the officially approved QGIS repositories settings = QgsSettings() settings.beginGroup(repo_settings_group()) if settings.value(repo_name + '/url') in \ self.repository_manager._online_directories.values(): self.message_bar.pushMessage( self.tr('You can not edit the official repositories!'), Qgis.Warning, 5) return dlg = ManageRepositoryDialog(self) dlg.line_edit_name.setText(repo_name) dlg.line_edit_url.setText( self.repository_manager.directories[repo_name]['url']) dlg.line_edit_auth_id.setText( self.repository_manager.directories[repo_name]['auth_cfg']) if not dlg.exec_(): return # Check if the changed URL is already present and that # the new repository name is unique new_url = dlg.line_edit_url.text().strip() old_url = self.repository_manager.directories[repo_name]['url'] new_name = dlg.line_edit_name.text().strip() for repoName, repo in self.repository_manager.directories.items(): if new_url == repo['url'] and (old_url != new_url): self.message_bar.pushMessage( self.tr('Unable to add another repository with the same ' 'URL!'), Qgis.Warning, 5) return if new_name == repoName and (repo_name != new_name): self.message_bar.pushMessage( self.tr('Repositories must have unique names!'), Qgis.Warning, 5) return # Redundant if (new_name in self.repository_manager.directories) and (new_name != repo_name): new_name += '(2)' new_auth_cfg = dlg.line_edit_auth_id.text() # Show progress dialog self.show_progress_dialog("Fetching repository's metadata") # Edit repository try: status, editerror = self.repository_manager.edit_directory( repo_name, new_name, old_url, new_url, new_auth_cfg) if status: self.message_bar.pushMessage( self.tr('Repository is successfully updated'), Qgis.Success, 5) else: self.message_bar.pushMessage( self.tr('Unable to edit repository: %s') % editerror, Qgis.Warning, 5) except Exception as e: self.message_bar.pushMessage(self.tr('%s') % e, Qgis.Warning, 5) finally: self.progress_dialog.hide() # Reload data and widget self.reload_data_and_widget() # Deactivate the edit and delete buttons self.button_edit.setEnabled(False) self.button_delete.setEnabled(False) def delete_repository(self): """Delete a repository in the tree widget.""" selected_item = self.tree_repositories.currentItem() if selected_item: repo_name = selected_item.text(0) if not repo_name: return # Check if it is among the offical repositories repo_url = self.repository_manager.directories[repo_name]['url'] if repo_url in self.repository_manager._online_directories.values(): self.message_bar.pushMessage( self.tr('You can not remove official repositories!'), Qgis.Warning, 5) return warning = self.tr('Are you sure you want to remove the following ' 'repository?') + '\n' + repo_name if QMessageBox.warning(self, self.tr('QGIS Resource Sharing'), warning, QMessageBox.Yes, QMessageBox.No) == QMessageBox.No: return # Remove repository installed_collections = \ self.collection_manager.get_installed_collections(repo_url) if installed_collections: message = ('You have installed collections from this ' 'repository. Please uninstall them first!') self.message_bar.pushMessage(message, Qgis.Warning, 5) else: self.repository_manager.remove_directory(repo_name) # Reload data and widget self.reload_data_and_widget() # Deactivate the edit and delete buttons self.button_edit.setEnabled(False) self.button_delete.setEnabled(False) def reload_repositories(self): """Slot for when user clicks reload repositories button.""" # Show progress dialog self.show_progress_dialog('Reloading all repositories') for repo_name in self.repository_manager.directories: directory = self.repository_manager.directories[repo_name] url = directory['url'] auth_cfg = directory['auth_cfg'] try: status, reloaderror = self.repository_manager.reload_directory( repo_name, url, auth_cfg) if status: self.message_bar.pushMessage( self.tr('Repository %s is successfully reloaded') % repo_name, Qgis.Info, 5) else: self.message_bar.pushMessage( self.tr('Unable to reload %s: %s') % (repo_name, reloaderror), Qgis.Warning, 5) except Exception as e: self.message_bar.pushMessage( self.tr('%s') % e, Qgis.Warning, 5) self.progress_dialog.hide() # Reload data and widget self.reload_data_and_widget() def install_collection(self): """Slot for when the user clicks the install/reinstall button.""" # Save the current index to enable selection after installation self.current_index = self.list_view_collections.currentIndex() self.show_progress_dialog('Starting installation...') self.progress_dialog.canceled.connect(self.install_canceled) self.installer_thread = QThread() self.installer_worker = CollectionInstaller( self.collection_manager, self._selected_collection_id) self.installer_worker.moveToThread(self.installer_thread) self.installer_worker.finished.connect(self.install_finished) self.installer_worker.aborted.connect(self.install_aborted) self.installer_worker.progress.connect(self.install_progress) self.installer_thread.started.connect(self.installer_worker.run) self.installer_thread.start() def install_finished(self): # Process the result self.progress_dialog.hide() installStatus = self.installer_worker.install_status if not installStatus: message = self.installer_worker.error_message # Clean up the worker and thread self.installer_worker.deleteLater() self.installer_thread.quit() self.installer_thread.wait() self.installer_thread.deleteLater() if installStatus: self.reload_collections_model() # Report what has been installed message = '<b>%s</b> was successfully installed, containing:\n<ul>' % ( config.COLLECTIONS[self._selected_collection_id]['name']) number = 0 if 'style' in config.COLLECTIONS[ self._selected_collection_id].keys(): number = config.COLLECTIONS[ self._selected_collection_id]['style'] message = message + '\n<li> ' + str( number) + ' Layer style (QML) file' if number > 1: message = message + 's' if 'symbol' in config.COLLECTIONS[ self._selected_collection_id].keys(): number = config.COLLECTIONS[ self._selected_collection_id]['symbol'] message = message + '\n<li> ' + str( number) + ' XML symbol file' if number > 1: message = message + 's' if 'svg' in config.COLLECTIONS[ self._selected_collection_id].keys(): number = config.COLLECTIONS[ self._selected_collection_id]['svg'] message = message + '\n<li> ' + str(number) + ' SVG file' if number > 1: message = message + 's' if 'models' in config.COLLECTIONS[ self._selected_collection_id].keys(): number = config.COLLECTIONS[ self._selected_collection_id]['models'] message = message + '\n<li> ' + str(number) + ' model' if number > 1: message = message + 's' if 'expressions' in config.COLLECTIONS[ self._selected_collection_id].keys(): number = config.COLLECTIONS[ self._selected_collection_id]['expressions'] message = message + '\n<li> ' + str( number) + ' expression file' if number > 1: message = message + 's' if 'processing' in config.COLLECTIONS[ self._selected_collection_id].keys(): number = config.COLLECTIONS[ self._selected_collection_id]['processing'] message = message + '\n<li> ' + str( number) + ' processing script' if number > 1: message = message + 's' if 'rscripts' in config.COLLECTIONS[ self._selected_collection_id].keys(): number = config.COLLECTIONS[ self._selected_collection_id]['rscripts'] message = message + '\n<li> ' + str(number) + ' R script' if number > 1: message = message + 's' message = message + '\n</ul>' QMessageBox.information(self, 'Resource Sharing', message) self.populate_repositories_widget() # Set the selection oldRow = self.current_index.row() newIndex = self.collections_model.createIndex(oldRow, 0) selection_model = self.list_view_collections.selectionModel() selection_model.setCurrentIndex(newIndex, selection_model.ClearAndSelect) selection_model.select(newIndex, selection_model.ClearAndSelect) # Update the buttons self.button_install.setEnabled(True) self.button_install.setText('Reinstall') self.button_open.setEnabled(True) self.button_uninstall.setEnabled(True) self.show_collection_metadata(self._selected_collection_id) def install_canceled(self): self.progress_dialog.hide() self.show_progress_dialog('Cancelling installation...') self.installer_worker.abort() def install_aborted(self): if self.installer_thread.isRunning(): self.installer_thread.quit() self.installer_thread.finished.connect(self.progress_dialog.hide) def install_progress(self, text): self.progress_dialog.setLabelText(text) def uninstall_collection(self): """Slot called when user clicks the uninstall button.""" # get the QModelIndex for the item to be uninstalled uninstall_index = self.list_view_collections.currentIndex() coll_id = self._selected_collection_id try: self.collection_manager.uninstall(coll_id) except Exception as e: LOGGER.error('Could not uninstall collection ' + config.COLLECTIONS[coll_id]['name'] + ':\n' + str(e)) else: QMessageBox.information( self, 'Resource Sharing', 'The collection was successfully uninstalled!') self.reload_collections_model() # Fix the GUI currentMenuRow = self.menu_list_widget.currentRow() self.set_current_tab(currentMenuRow) self.populate_repositories_widget() rowCount = self.collection_proxy.rowCount() if rowCount > 0: # Set the current (and selected) row in the listview newRow = uninstall_index.row() # Check if this was the last element rowCount = self.collection_proxy.rowCount() if newRow == rowCount: newRow = newRow - 1 # Select the new current element newIndex = self.collections_model.createIndex(newRow, 0) selection_model = self.list_view_collections.selectionModel() selection_model.setCurrentIndex(newIndex, selection_model.ClearAndSelect) # Get the id of the current collection proxyModel = self.list_view_collections.model() proxyIndex = proxyModel.index(newRow, 0) current_coll_id = proxyIndex.data(COLLECTION_ID_ROLE) self._selected_collection_id = current_coll_id # Update buttons status = config.COLLECTIONS[current_coll_id]['status'] if status == COLLECTION_INSTALLED_STATUS: self.button_install.setEnabled(True) self.button_install.setText('Reinstall') self.button_open.setEnabled(True) self.button_uninstall.setEnabled(True) else: self.button_install.setEnabled(True) self.button_install.setText('Install') self.button_open.setEnabled(False) self.button_uninstall.setEnabled(False) # Update the web_view_details frame self.show_collection_metadata(current_coll_id) else: self.button_install.setEnabled(False) self.button_install.setText('Install') self.button_open.setEnabled(False) self.button_uninstall.setEnabled(False) def open_collection(self): """Slot for when user clicks 'Open' button.""" collection_path = local_collection_path(self._selected_collection_id) directory_url = QUrl.fromLocalFile(str(collection_path)) QDesktopServices.openUrl(directory_url) def reload_data_and_widget(self): """Reload repositories and collections and update widgets related.""" self.reload_repositories_widget() self.reload_collections_model() def reload_repositories_widget(self): """Refresh tree repositories using new repositories data.""" self.repository_manager.load_directories() self.populate_repositories_widget() def populate_repositories_widget(self): """Populate the current dictionary repositories to the tree widget.""" # Clear the current tree widget self.tree_repositories.clear() installed_collections = \ self.collection_manager.get_installed_collections() # Export the updated ones from the repository manager for repo_name in self.repository_manager.directories: url = self.repository_manager.directories[repo_name]['url'] item = QTreeWidgetItem(self.tree_repositories, REPOSITORY_ITEM) item.setText(0, repo_name) item.setText(1, url) for coll_id in config.COLLECTIONS: if ('repository_name' in config.COLLECTIONS[coll_id].keys() and config.COLLECTIONS[coll_id]['repository_name'] == repo_name): coll_name = config.COLLECTIONS[coll_id]['name'] coll_tags = config.COLLECTIONS[coll_id]['tags'] collectionItem = QTreeWidgetItem(item, COLLECTION_ITEM) collitemtext = coll_name if installed_collections and coll_id in installed_collections.keys( ): collitemtext = coll_name + ' (installed)' collectionFont = QFont() collectionFont.setWeight(60) collectionItem.setFont(0, collectionFont) collectionItem.setText(0, collitemtext) collectionItem.setText(1, coll_tags) self.tree_repositories.resizeColumnToContents(0) self.tree_repositories.resizeColumnToContents(1) self.tree_repositories.sortItems(1, Qt.AscendingOrder) def reload_collections_model(self): """Reload the collections model with the current collections.""" self.collections_model.clear() installed_collections = \ self.collection_manager.get_installed_collections() for id in config.COLLECTIONS: collection_name = config.COLLECTIONS[id]['name'] collection_author = config.COLLECTIONS[id]['author'] collection_tags = config.COLLECTIONS[id]['tags'] collection_description = config.COLLECTIONS[id]['description'] collection_status = config.COLLECTIONS[id]['status'] repository_name = '' if 'repository_name' in config.COLLECTIONS[id].keys(): repository_name = config.COLLECTIONS[id]['repository_name'] item = QStandardItem(collection_name + ' (' + repository_name + ')') item.setEditable(False) item.setData(id, COLLECTION_ID_ROLE) item.setData(collection_name, COLLECTION_NAME_ROLE) item.setData(collection_description, COLLECTION_DESCRIPTION_ROLE) item.setData(collection_author, COLLECTION_AUTHOR_ROLE) item.setData(collection_tags, COLLECTION_TAGS_ROLE) item.setData(collection_status, COLLECTION_STATUS_ROLE) # Make installed collections stand out if installed_collections and id in installed_collections.keys(): collectionFont = QFont() collectionFont.setWeight(60) item.setFont(collectionFont) self.collections_model.appendRow(item) self.collections_model.sort(0, Qt.AscendingOrder) def on_tree_repositories_itemSelectionChanged(self): """Slot for the itemSelectionChanged signal of tree_repositories.""" selected_item = self.tree_repositories.currentItem() if selected_item and selected_item.type() == REPOSITORY_ITEM: if selected_item: repo_name = selected_item.text(0) if not repo_name: return if not repo_name in self.repository_manager.directories.keys(): return repo_url = self.repository_manager.directories[repo_name]['url'] # Disable the edit and delete buttons for "official" repositories if repo_url in self.repository_manager._online_directories.values( ): self.button_edit.setEnabled(False) self.button_delete.setEnabled(False) else: # Activate the edit and delete buttons self.button_edit.setEnabled(True) self.button_delete.setEnabled(True) elif selected_item and selected_item.type() == COLLECTION_ITEM: self.button_edit.setEnabled(False) self.button_delete.setEnabled(False) else: self.button_edit.setEnabled(False) self.button_delete.setEnabled(False) def on_list_view_collections_clicked(self, index): """Slot for when the list_view_collections is clicked.""" real_index = self.collection_proxy.mapToSource(index) if real_index.row() != -1: collection_item = self.collections_model.itemFromIndex(real_index) collection_id = collection_item.data(COLLECTION_ID_ROLE) self._selected_collection_id = collection_id # Enable / disable buttons status = config.COLLECTIONS[self._selected_collection_id]['status'] is_installed = status == COLLECTION_INSTALLED_STATUS if is_installed: self.button_install.setEnabled(True) self.button_install.setText('Reinstall') self.button_open.setEnabled(True) self.button_uninstall.setEnabled(True) else: self.button_install.setEnabled(True) self.button_install.setText('Install') self.button_open.setEnabled(False) self.button_uninstall.setEnabled(False) # Show metadata self.show_collection_metadata(collection_id) @pyqtSlot(str) def filter_collections(self, text): search = QRegExp(text, Qt.CaseInsensitive, QRegExp.RegExp) self.collection_proxy.setFilterRegExp(search) def show_collection_metadata(self, id): """Show the collection metadata given the ID.""" html = self.collection_manager.get_html(id) self.web_view_details.setHtml(html) def reject(self): """Slot when the dialog is closed.""" # Serialize collections to settings self.repository_manager.serialize_repositories() self.done(0) def open_help(self): """Open help.""" doc_url = QUrl('http://qgis-contribution.github.io/' + 'QGIS-ResourceSharing/') QDesktopServices.openUrl(doc_url) def show_progress_dialog(self, text): """Show infinite progress dialog with given text. :param text: Text as the label of the progress dialog :type text: str """ if self.progress_dialog is None: self.progress_dialog = QProgressDialog(self) self.progress_dialog.setWindowModality(Qt.WindowModal) self.progress_dialog.setAutoClose(False) title = self.tr('Resource Sharing') self.progress_dialog.setWindowTitle(title) # Just use an infinite progress bar here self.progress_dialog.setMaximum(0) self.progress_dialog.setMinimum(0) self.progress_dialog.setValue(0) self.progress_dialog.setLabelText(text) self.progress_dialog.show()
class 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 contentAuthDlg(WIDGET, BASE): ''' Content authorization dialog ''' def __init__(self, plugin): QDialog.__init__(self, plugin.iface.mainWindow()) self.setupUi(self) QgsGui.enableAutoGeometryRestore(self) # Initialize the dialog self.initGui() # Load users self.loadContent() # Load Roles self.loadRoles() # Reference to the currently selected STDM content item self.currentContent = None def initGui(self): ''' Initialize GUI properties ''' # Disable any action by the user in the roles view self.lstRoles.setEnabled(False) # Connect signals self.lstContent.activated.connect(self.onContentClicked) self.lstContent.clicked.connect(self.onContentClicked) self.lstRoles.activated.connect(self.onRoleSelected) self.lstRoles.clicked.connect(self.onRoleSelected) def loadContent(self): ''' Loads STDM content items ''' self.content = Content() # self.content=Table('content_base',Base.metadata,autoload=True,autoload_with=STDMDb.instance().engine) cntItems = self.content.queryObject().all() ''' self.content=Table('content_base',Base.metadata,autoload=True,autoload_with=STDMDb.instance().engine) session= STDMDb.instance().session cntItems=session.query(self.content) ''' cnts = [cntItem.name for cntItem in cntItems] self.contentModel = UsersRolesModel(cnts) self.lstContent.setModel(self.contentModel) def loadRoles(self, contentname=""): ''' Loads the roles in the database cluster ''' self.roleProvider = RoleProvider() sysRoles = self.roleProvider.GetAllRoles() roles = [] # Load the corresponding roles for the specified content item cnt = Content() if contentname != "": self.currentContent = self.content.queryObject().filter( Content.name == contentname).first() if self.currentContent: roles = [rl.name for rl in self.currentContent.roles] # Initialize model self.roleMappingsModel = QStandardItemModel(self) self.roleMappingsModel.setColumnCount(1) # Add role items into the standard item model for r in range(len(sysRoles)): role = sysRoles[r] if role.name != "postgres": roleItem = self._createNewRoleItem(role.name) # Check if the db role is in the approved for the current content item roleIndex = getIndex(roles, role.name) if roleIndex != -1: roleItem.setCheckState(Qt.Checked) self.roleMappingsModel.appendRow(roleItem) self.lstRoles.setModel(self.roleMappingsModel) def _createNewRoleItem(self, rolename): ''' Creates a custom role item for use in a QStandardItemModel ''' # Set icon icon = QIcon() icon.addPixmap(GuiUtils.get_icon_pixmap("roles.png"), QIcon.Normal, QIcon.Off) roleItem = QStandardItem(icon, rolename) roleItem.setCheckable(True) roleItem.setCheckState(Qt.Unchecked) return roleItem def onContentClicked(self, index): ''' Slot activated when a content item is selected to load the roles for the specified content items ''' self.lstRoles.setEnabled(True) contentName = index.data() self.loadRoles(contentName) self.privilege_provider = SinglePrivilegeProvider( contentName, current_profile()) def onRoleSelected(self, index): ''' Slot which is called when a user checks/unchecks to add/remove a role for the specified content item. ''' if self.currentContent != None: item = self.roleMappingsModel.itemFromIndex(index) rolename = item.text() self.privilege_provider.role = rolename # Get role object from role name role = Role() rl = role.queryObject().filter(Role.name == rolename).first() self.blockSignals(True) # Add role to the content item if the item is selected or remove if it was previosuly checked if item.checkState() == Qt.Checked: self.currentContent.roles.append(rl) self.privilege_provider.grant_privilege() elif item.checkState() == Qt.Unchecked: self.currentContent.roles.remove(rl) self.privilege_provider.revoke_privilege() self.currentContent.update() self.blockSignals(False)
class checkableMapLayerList(QWidget): # create a checkable list of the map layers def __init__(self, parent=None): QWidget.__init__(self, parent) layerList = QgsProject.instance().layerTreeRoot().findLayers() self.iface = iface """for layer in layerList: print(layer.name())""" self.selectedLayers = [] layout = QVBoxLayout() self.model = QStandardItemModel() self.select_all_cb = QCheckBox('Check All') self.select_all_cb.setChecked(True) self.select_all_cb.setStyleSheet('margin-left: 5px; font: bold') #self.select_all_cb.stateChanged.connect(lambda: selectAllCheckChanged(select_all_cb, model)) layout.addWidget(self.select_all_cb) self.view = QListView() self.view.setEditTriggers(QAbstractItemView.NoEditTriggers) self.view.setSelectionMode(QAbstractItemView.NoSelection) self.view.setSelectionRectVisible(False) for layer in layerList: item = QStandardItem(layer.name()) # item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled) # item.setData(QVariant(Qt.Checked), Qt.CheckStateRole) item.setCheckable(True) item.setSelectable(False) item.setCheckState(QtCore.Qt.Checked) self.model.appendRow(item) self.selectedLayers.append(item) self.view.setModel(self.model) #view.clicked.connect(lambda: listviewCheckChanged(item, model, select_all_cb)) layout.addWidget(self.view) self.setLayout(layout) """if parent: parent.setLayout(layout) else: window = QWidget() window.setLayout(layout)""" #window.show() def selectAllCheckChanged(self, select_all_cb, model): TOMsMessageLog.logMessage("IN selectAllCheckChanged", level=Qgis.Info) for index in range(model.rowCount()): item = model.item(index) if item.isCheckable(): if select_all_cb.isChecked(): item.setCheckState(QtCore.Qt.Checked) self.selectedLayers.append(item) else: item.setCheckState(QtCore.Qt.Unchecked) self.selectedLayers.remove(item) TOMsMessageLog.logMessage( "IN selectAllCheckChanged: len list {}".format( len(self.selectedLayers)), level=Qgis.Info) def listviewCheckChanged(self, model, select_all_cb): ''' updates the select all checkbox based on the listview ''' # model = self.listview.model() TOMsMessageLog.logMessage("IN listviewCheckChanged", level=Qgis.Info) items = [model.item(index) for index in range(model.rowCount())] if all(item.checkState() == QtCore.Qt.Checked for item in items): select_all_cb.setTristate(False) select_all_cb.setCheckState(QtCore.Qt.Checked) elif any(item.checkState() == QtCore.Qt.Checked for item in items): select_all_cb.setTristate(True) select_all_cb.setCheckState(QtCore.Qt.PartiallyChecked) else: select_all_cb.setTristate(False) select_all_cb.setCheckState(QtCore.Qt.Unchecked) def updateSelectedLayers(self, index): #QMessageBox.information(self.iface.mainWindow(), "debug", "IN updateSelectedLayers: {}".format(self.model.itemFromIndex(index))) TOMsMessageLog.logMessage("IN updateSelectedLayers: {}".format(index), level=Qgis.Info) item = self.model.itemFromIndex(index) if item.checkState() == QtCore.Qt.Checked: self.selectedLayers.append(item) else: self.selectedLayers.remove(item) def getSelectedLayers(self): return self.selectedLayers
class QVDistrictesBarris(QObject): __distBarrisCSV = r'Dades\DIST_BARRIS.csv' __zones = r'Dades\Zones.gpkg' def __init__(self): super().__init__() self.labels = [] self.registre = {} # Model self.model = QStandardItemModel() self.llegirZonesGPKG() #self.llegirDistrictesBarrisCSV() # View self.view = QTreeView() self.view.setContextMenuPolicy(Qt.ActionsContextMenu) self.actExpand = QAction("Expandeix/Contreu Tot", self) self.actExpand.setStatusTip("Expand") self.actExpand.triggered.connect(self.expand_all) self.view.addAction(self.actExpand) self.view.setModel(self.model) self.iniView() def expand_all(self): """Expandir o contraer todo el arbol, dependiendo de si detecta que esta extendido o contraido """ if self.view.isExpanded(self.model.index(0, 0, QModelIndex())): self.view.collapseAll() else: self.view.expandAll() def iniView(self): self.view.setHeaderHidden(True) for i in range(self.model.columnCount()): if i == 0: self.view.setColumnHidden(i, False) self.view.resizeColumnToContents(i) self.view.resizeColumnToContents(i) else: self.view.setColumnHidden(i, True) self.view.setEditTriggers(QTreeView.NoEditTriggers) self.expand_all() def llegirZonesGPKG(self): try: QvFuncions.setReadOnlyFile(self.__zones) pathDistrictes = self.__zones + '|layername=districtes' layerDistrictes = QgsVectorLayer(pathDistrictes, 'ogr') pathBarris = self.__zones + '|layername=barris' layerBarris = QgsVectorLayer(pathBarris, 'ogr') rowsDistrictes = layerDistrictes.getFeatures() llistaDistrictes = [] for rowD in rowsDistrictes: #print(rowD.attributes()) #zona = "" num_districte = rowD.attributes()[1] nom_districte = rowD.attributes()[2] num_barri = "" nom_barri = "" geometria = rowD.geometry().boundingBox() x_min = str(geometria.xMinimum()) y_min = str(geometria.yMinimum()) x_max = str(geometria.xMaximum()) y_max = str(geometria.yMaximum()) item = [ num_districte, nom_districte, num_barri, nom_barri, x_min, y_min, x_max, y_max ] llistaDistrictes.append(item) def ordenaPerNumDistricte(elem): return elem[0] llistaDistrictes.sort(key=ordenaPerNumDistricte) #print(llistaDistrictes) rowsBarris = layerBarris.getFeatures() llistaBarris = [] for rowB in rowsBarris: #print(rowB.attributes()) #zona = "" num_districte = rowB.attributes()[3] nom_districte = llistaDistrictes[int(num_districte) - 1][1] num_barri = rowB.attributes()[1] nom_barri = rowB.attributes()[2] geometria = rowB.geometry().boundingBox() x_min = str(geometria.xMinimum()) y_min = str(geometria.yMinimum()) x_max = str(geometria.xMaximum()) y_max = str(geometria.yMaximum()) item = [ num_districte, nom_districte, num_barri, nom_barri, x_min, y_min, x_max, y_max ] llistaBarris.append(item) def ordenaPerNumBarri(elem): return elem[2] llistaBarris.sort(key=ordenaPerNumBarri) #print(llistaBarris) self.labels = [ "ZONA", "DISTRICTE", "NOM_DISTRICTE", "BARRI", "NOM_BARRI", "X_MIN", "Y_MIN", "X_MAX", "Y_MAX" ] root = self.model.invisibleRootItem() self.model.setColumnCount(len(self.labels)) self.model.setHorizontalHeaderLabels(self.labels) #Afegir Barcelona com a arrel de l'arbre bcn_dades = [ "00", "Barcelona", "00", "Barcelona", "419710.0553820258", "4573818.80776309", "436533.35", "4591775.02" ] bcn = [QStandardItem("Barcelona")] for item in bcn_dades: bcn.append(QStandardItem(item)) root.appendRow(bcn) ultimaDistr = -1 itDist = 0 for b in llistaBarris: if ultimaDistr != int(b[0]): #Afegir següent districte dist = [QStandardItem(llistaDistrictes[itDist][1])] for i in range(0, len(llistaDistrictes[itDist])): dist.append(QStandardItem(llistaDistrictes[itDist][i])) bcn[0].appendRow(dist) itDist = itDist + 1 #Afegir següent Barri barri = [QStandardItem(b[3])] for item in b: barri.append(QStandardItem(item)) dist[0].appendRow(barri) ultimaDistr = int(b[0]) return True except: print("Error en construcció de l'arbre de zones") return False # def llegirDistrictesBarrisCSV(self): # try: # first = True # with open(self.__distBarrisCSV, newline='') as csvFile: # reader = csv.DictReader(csvFile, delimiter=';') # root = self.model.invisibleRootItem() # for row in reader: # if first: # Primer registro # self.labels = ['ZONA'] # for item in row: # self.labels.append(item) # self.model.setColumnCount(len(self.labels)) # self.model.setHorizontalHeaderLabels(self.labels) # first = False # if row['BARRI'] == '': # Registro de distrito # dist = [QStandardItem(row['NOM_DISTRICTE'])] # for item in row.values(): # dist.append(QStandardItem(item)) # root.appendRow(dist) # else: # Registro de barrio # barri = [QStandardItem(row['NOM_BARRI'])] # for item in row.values(): # barri.append(QStandardItem(item)) # dist[0].appendRow(barri) # return True # except: # print('QDistrictesBarris.llegirDistrictesBarrisCSV(): ', sys.exc_info()[0], sys.exc_info()[1]) # return False def llegirRegistre(self): try: click = self.view.currentIndex() #Controlarem si s'ha canviat d'índex o no if hasattr(self, 'ultimIndex') and self.ultimIndex == click: return self.registre self.ultimIndex = click self.registre = {} for i in range(self.model.columnCount()): index = click.sibling(click.row(), i) item = self.model.itemFromIndex(index) self.registre[self.labels[i]] = item.text() self.registre['RANG'] = QgsRectangle(float(self.registre['X_MIN']), \ float(self.registre['Y_MIN']), \ float(self.registre['X_MAX']), \ float(self.registre['Y_MAX'])) except: print('QDistrictesBarris.llegirRegistre(): ', sys.exc_info()[0], sys.exc_info()[1]) finally: return self.registre def llegirRang(self): return self.llegirRegistre()['RANG'] def esDistricte(self): return self.llegirRegistre()['BARRI'] == '' def esBarri(self): return not self.esDistricte() def llegirNom(self): if self.esDistricte(): distr = self.llegirRegistre()["NOM_DISTRICTE"] distr_d = distr + "_d" return distr_d else: barri = self.llegirRegistre()["NOM_BARRI"] if barri == "Barcelona": return barri else: barri_b = barri + "_b" return barri_b def llegirID(self): if self.esDistricte(): return self.llegirRegistre()['DISTRICTE'] return self.llegirRegistre()['BARRI']
class SPAQLunicornDialog(QtWidgets.QDialog, FORM_CLASS): ## The triple store configuration file triplestoreconf = None ## Prefix map prefixes = None enrichtab = None interlinktab = None conceptList = None completerClassList = None columnvars = {} def __init__(self, triplestoreconf={}, prefixes=[], addVocabConf={}, autocomplete={}, prefixstore={ "normal": {}, "reversed": {} }, savedQueriesJSON={}, maindlg=None, parent=None): """Constructor.""" super(SPAQLunicornDialog, self).__init__(parent) self.setupUi(self) self.prefixes = prefixes self.maindlg = maindlg self.savedQueriesJSON = savedQueriesJSON self.enrichtab = EnrichmentTab(self) self.interlinktab = InterlinkingTab(self) self.addVocabConf = addVocabConf self.autocomplete = autocomplete self.prefixstore = prefixstore self.triplestoreconf = triplestoreconf self.searchTripleStoreDialog = TripleStoreDialog( self.triplestoreconf, self.prefixes, self.prefixstore, self.comboBox) self.geoClassList.setEditTriggers(QAbstractItemView.NoEditTriggers) self.geoClassList.setAlternatingRowColors(True) self.geoClassList.setViewMode(QListView.ListMode) self.geoClassList.setContextMenuPolicy(Qt.CustomContextMenu) self.geoClassList.customContextMenuRequested.connect(self.onContext) self.geoClassListModel = QStandardItemModel() self.proxyModel = QSortFilterProxyModel(self) self.proxyModel.sort(0) self.proxyModel.setSourceModel(self.geoClassListModel) self.geoClassList.setModel(self.proxyModel) self.geoClassListModel.clear() self.queryLimit.setValidator(QRegExpValidator(QRegExp("[0-9]*"))) self.filterConcepts.textChanged.connect(self.setFilterFromText) self.inp_sparql2 = ToolTipPlainText(self.tab, self.triplestoreconf, self.comboBox, self.columnvars, self.prefixes, self.autocomplete) self.inp_sparql2.move(10, 130) self.inp_sparql2.setMinimumSize(780, 401) self.inp_sparql2.document().defaultFont().setPointSize(16) self.inp_sparql2.setPlainText( "SELECT ?item ?lat ?lon WHERE {\n ?item ?b ?c .\n ?item <http://www.wikidata.org/prop:P123> ?def .\n}" ) self.inp_sparql2.columnvars = {} self.inp_sparql2.textChanged.connect(self.validateSPARQL) self.sparqlhighlight = SPARQLHighlighter(self.inp_sparql2) self.areaconcepts.hide() self.areas.hide() self.label_8.hide() self.label_9.hide() self.savedQueries.hide() self.loadQuery.hide() self.saveQueryButton.hide() self.saveQueryName.hide() self.savedQueryLabel.hide() self.saveQueryName_2.hide() self.enrichTableResult.hide() self.queryTemplates.currentIndexChanged.connect(self.viewselectaction) self.bboxButton.clicked.connect(self.getPointFromCanvas) self.interlinkTable.cellClicked.connect( self.createInterlinkSearchDialog) self.enrichTable.cellClicked.connect(self.createEnrichSearchDialog) self.chooseLayerInterlink.clear() self.searchClass.clicked.connect(self.createInterlinkSearchDialog) urlregex = QRegExp( "http[s]?://(?:[a-zA-Z#]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+" ) urlvalidator = QRegExpValidator(urlregex, self) self.interlinkNameSpace.setValidator(urlvalidator) self.interlinkNameSpace.textChanged.connect(self.check_state3) self.interlinkNameSpace.textChanged.emit( self.interlinkNameSpace.text()) self.addEnrichedLayerButton.clicked.connect( self.enrichtab.addEnrichedLayer) self.startEnrichment.clicked.connect(self.enrichtab.enrichLayerProcess) self.exportInterlink.clicked.connect( self.enrichtab.exportEnrichedLayer) self.loadQuery.clicked.connect(self.loadQueryFunc) self.saveQueryButton.clicked.connect(self.saveQueryFunc) self.exportMappingButton.clicked.connect( self.interlinktab.exportMapping) self.importMappingButton.clicked.connect(self.interlinktab.loadMapping) self.loadLayerInterlink.clicked.connect(self.loadLayerForInterlink) self.loadLayerEnrich.clicked.connect(self.loadLayerForEnrichment) self.addEnrichedLayerRowButton.clicked.connect(self.addEnrichRow) self.geoClassList.selectionModel().selectionChanged.connect( self.viewselectaction) self.loadFileButton.clicked.connect(self.buildLoadGraphDialog) self.refreshLayersInterlink.clicked.connect(self.loadUnicornLayers) self.btn_loadunicornlayers.clicked.connect(self.loadUnicornLayers) self.whattoenrich.clicked.connect(self.createWhatToEnrich) self.quickAddTripleStore.clicked.connect(self.buildQuickAddTripleStore) self.loadTripleStoreButton.clicked.connect( self.buildCustomTripleStoreDialog) self.loadUnicornLayers() def loadQueryFunc(self): if self.triplestoreconf[self.comboBox.currentIndex( )]["endpoint"] in self.savedQueriesJSON: self.inp_sparql2.setPlainText(self.savedQueriesJSON[ self.triplestoreconf[self.comboBox.currentIndex()] ["endpoint"]][self.savedQueries.currentIndex()]["query"]) def saveQueryFunc(self): queryName = self.saveQueryName.text() if queryName != None and queryName != "": __location__ = os.path.realpath( os.path.join(os.getcwd(), os.path.dirname(__file__))) self.savedQueriesJSON[self.triplestoreconf[ self.comboBox.currentIndex()]["endpoint"]].append({ "label": queryName, "query": self.inp_sparql2.toPlainText() }) self.savedQueries.addItem(queryName) f = open(os.path.join(__location__, 'savedqueries.json'), "w") f.write(json.dumps(self.savedQueriesJSON)) f.close() def onContext(self): menu = QMenu("Menu", self.geoClassList) action = QAction("Open in Webbrowser") menu.addAction(action) action.triggered.connect(self.openURL) def openURL(self): curindex = self.proxyModel.mapToSource( self.geoClassList.selectionModel().currentIndex()) concept = self.geoClassListModel.itemFromIndex(curindex).data(1) url = QUrl(concept) QDesktopServices.openUrl(url) def setFilterFromText(self): self.proxyModel.setFilterRegExp(self.filterConcepts.text()) ## # @brief Creates a What To Enrich dialog with parameters given. # # @param self The object pointer def buildLoadGraphDialog(self): self.searchTripleStoreDialog = LoadGraphDialog(self.triplestoreconf, self.maindlg, self) self.searchTripleStoreDialog.setWindowTitle("Load Graph") self.searchTripleStoreDialog.exec_() ## # @brief Creates a What To Enrich dialog with parameters given. # # @param self The object pointer def buildQuickAddTripleStore(self): self.searchTripleStoreDialog = TripleStoreQuickAddDialog( self.triplestoreconf, self.prefixes, self.prefixstore, self.comboBox) self.searchTripleStoreDialog.setMinimumSize(580, 186) self.searchTripleStoreDialog.setWindowTitle( "Configure Own Triple Store") self.searchTripleStoreDialog.exec_() ## # @brief Creates a What To Enrich dialog with parameters given. # # @param self The object pointer def buildCustomTripleStoreDialog(self): self.searchTripleStoreDialog = TripleStoreDialog( self.triplestoreconf, self.prefixes, self.prefixstore, self.comboBox) self.searchTripleStoreDialog.setMinimumSize(700, 500) self.searchTripleStoreDialog.setWindowTitle( "Configure Own Triple Store") self.searchTripleStoreDialog.exec_() ## # @brief Creates a What To Enrich dialog with parameters given. # # @param self The object pointer def createWhatToEnrich(self): if self.enrichTable.rowCount() == 0: return layers = QgsProject.instance().layerTreeRoot().children() selectedLayerIndex = self.chooseLayerEnrich.currentIndex() layer = layers[selectedLayerIndex].layer() self.searchTripleStoreDialog = EnrichmentDialog( self.triplestoreconf, self.prefixes, self.enrichTable, layer, None, None) self.searchTripleStoreDialog.setMinimumSize(700, 500) self.searchTripleStoreDialog.setWindowTitle("Enrichment Search") self.searchTripleStoreDialog.exec_() def check_state3(self): self.searchTripleStoreDialog.check_state(self.interlinkNameSpace) def createEnrichSearchDialog(self, row=-1, column=-1): if column == 1: self.buildSearchDialog(row, column, False, self.enrichTable, False, False, None, self.addVocabConf) if column == 6: self.buildSearchDialog(row, column, False, self.enrichTable, False, False, None, self.addVocabConf) def createEnrichSearchDialogProp(self, row=-1, column=-1): self.buildSearchDialog(row, column, False, self.findIDPropertyEdit, True, False, None, self.addVocabConf) ## # @brief Creates a search dialog with parameters for interlinking. # # @param self The object pointer # @param row The row of the table for which to map the search result # @param column The column of the table for which to map the search result def createInterlinkSearchDialog(self, row=-1, column=-1): if column > 3 and column < 7: self.buildSearchDialog(row, column, True, self.interlinkTable, True, False, None, self.addVocabConf) elif column >= 7: layers = QgsProject.instance().layerTreeRoot().children() selectedLayerIndex = self.chooseLayerInterlink.currentIndex() layer = layers[selectedLayerIndex].layer() self.buildValueMappingDialog(row, column, True, self.interlinkTable, layer) elif column == -1: self.buildSearchDialog(row, column, -1, self.interlinkOwlClassInput, False, False, None, self.addVocabConf) ## # @brief Shows the configuration table after creating an enrichment result. # # @param self The object pointer # def showConfigTable(self): self.enrichTableResult.hide() self.enrichTable.show() self.startEnrichment.setText("Start Enrichment") self.startEnrichment.clicked.disconnect() self.startEnrichment.clicked.connect(self.enrichtab.enrichLayerProcess) ## # @brief Executes a GUI event when a new SPARQL endpoint is selected. # Usually loads the list of concepts related to the SPARQL endpoint # @param send The sender of the request # def viewselectaction(self): endpointIndex = self.comboBox.currentIndex() if endpointIndex == 0: self.justloadingfromfile = False return concept = "" curindex = self.proxyModel.mapToSource( self.geoClassList.selectionModel().currentIndex()) if self.geoClassList.selectionModel().currentIndex( ) != None and self.geoClassListModel.itemFromIndex( curindex) != None and re.match( r'.*Q[0-9]+.*', self.geoClassListModel.itemFromIndex(curindex).text() ) and not self.geoClassListModel.itemFromIndex( curindex).text().startswith("http"): self.inp_label.setText( self.geoClassListModel.itemFromIndex(curindex).text().split( "(")[0].lower().replace(" ", "_")) concept = "Q" + self.geoClassListModel.itemFromIndex( curindex).text().split("Q")[1].replace(")", "") elif self.geoClassListModel.itemFromIndex(curindex) != None: concept = self.geoClassListModel.itemFromIndex(curindex).data(1) if "querytemplate" in self.triplestoreconf[endpointIndex]: if "wd:Q%%concept%% ." in self.triplestoreconf[endpointIndex][ "querytemplate"][ self.queryTemplates.currentIndex()]["query"]: querytext = "" if concept != None and concept.startswith("http"): querytext = self.triplestoreconf[endpointIndex][ "querytemplate"][self.queryTemplates.currentIndex( )]["query"].replace( "wd:Q%%concept%% .", "wd:" + concept[concept.rfind('/') + 1:] + " .") elif concept != None: querytext = self.triplestoreconf[endpointIndex][ "querytemplate"][self.queryTemplates.currentIndex( )]["query"].replace("wd:Q%%concept%% .", "wd:" + concept + " .") else: querytext = self.triplestoreconf[endpointIndex][ "querytemplate"][ self.queryTemplates.currentIndex()]["query"].replace( "%%concept%%", concept) if self.queryLimit.text().isnumeric( ) and querytext.rfind("LIMIT") != -1: querytext = querytext[0:querytext.rfind( "LIMIT")] + "LIMIT " + self.queryLimit.text() elif self.queryLimit.text().isnumeric() and querytext.rfind( "LIMIT") == -1: querytext = querytext + " LIMIT " + self.queryLimit.text() self.inp_sparql2.setPlainText(querytext) self.inp_sparql2.columnvars = {} if self.geoClassList.selectionModel().currentIndex( ) != None and self.geoClassListModel.itemFromIndex( curindex ) != None and "#" in self.geoClassListModel.itemFromIndex( curindex).text(): self.inp_label.setText( self.geoClassListModel.itemFromIndex(curindex).text() [self.geoClassListModel.itemFromIndex(curindex).text(). rfind('#') + 1:].lower().replace(" ", "_")) elif self.geoClassList.selectionModel().currentIndex( ) != None and self.geoClassListModel.itemFromIndex(curindex) != None: self.inp_label.setText( self.geoClassListModel.itemFromIndex(curindex).text() [self.geoClassListModel.itemFromIndex(curindex).text(). rfind('/') + 1:].lower().replace(" ", "_")) def itemModelToMap(self, model): resdict = {} for row in range(model.rowCount()): index = model.index(row, 0, self) resdict[model.itemFromIndex(index).text()] = model.itemFromIndex( index).data(1) return resdict ## # @brief Deletes a row from the table in the enrichment dialog. # # @param send The sender of the request # def deleteEnrichRow(send): w = send.sender().parent() row = self.enrichTable.indexAt(w.pos()).row() self.enrichTable.removeRow(row) self.enrichTable.setCurrentCell(0, 0) ## # @brief Adds a new row to the table in the enrichment dialog. # # @param self The object pointer # def addEnrichRow(self): layers = QgsProject.instance().layerTreeRoot().children() selectedLayerIndex = self.chooseLayerEnrich.currentIndex() layer = layers[selectedLayerIndex].layer() self.enrichTableResult.hide() fieldnames = [field.name() for field in layer.fields()] item = QTableWidgetItem("new_column") #item.setFlags(QtCore.Qt.ItemIsEnabled) row = self.enrichTable.rowCount() self.enrichTable.insertRow(row) self.enrichTable.setItem(row, 0, item) cbox = QComboBox() cbox.addItem("Get Remote") cbox.addItem("No Enrichment") cbox.addItem("Exclude") self.enrichTable.setCellWidget(row, 3, cbox) cbox = QComboBox() cbox.addItem("Enrich Value") cbox.addItem("Enrich URI") cbox.addItem("Enrich Both") self.enrichTable.setCellWidget(row, 4, cbox) cbox = QComboBox() for fieldd in fieldnames: cbox.addItem(fieldd) self.enrichTable.setCellWidget(row, 5, cbox) itemm = QTableWidgetItem("http://www.w3.org/2000/01/rdf-schema#label") self.enrichTable.setItem(row, 6, itemm) itemm = QTableWidgetItem("") self.enrichTable.setItem(row, 7, itemm) itemm = QTableWidgetItem("") self.enrichTable.setItem(row, 8, itemm) ## Validates the SPARQL query in the input field and outputs errors in a label. # @param self The object pointer. def validateSPARQL(self): if self.prefixes != None and self.comboBox != None and self.comboBox.currentIndex( ) != None and self.prefixes[self.comboBox.currentIndex( )] != None and self.inp_sparql2.toPlainText( ) != None and self.inp_sparql2.toPlainText() != "": try: if self.prefixes[self.comboBox.currentIndex()] != "": prepareQuery( "".join(self.prefixes[self.comboBox.currentIndex()]) + "\n" + self.inp_sparql2.toPlainText()) self.errorLabel.setText("Valid Query") self.errorline = -1 self.sparqlhighlight.errorhighlightline = self.errorline self.sparqlhighlight.currentline = 0 self.inp_sparql2.errorline = None except Exception as e: match = re.search(r'line:([0-9]+),', str(e)) match2 = re.search(r'col:([0-9]+),', str(e)) start = int(match.group(1)) - len(self.triplestoreconf[ self.comboBox.currentIndex()]["prefixes"]) - 1 self.errorLabel.setText( re.sub("line:([0-9]+),", "line: " + str(start) + ",", str(e))) self.inp_sparql2.errorline = start - 1 if "line" in str(e): ex = str(e) start = ex.find('line:') + 5 end = ex.find(',', start) start2 = ex.find('col:') + 4 end2 = ex.find(')', start2) self.errorline = ex[start:end] self.sparqlhighlight.errorhighlightcol = ex[start2:end2] self.sparqlhighlight.errorhighlightline = self.errorline self.sparqlhighlight.currentline = 0 ## # @brief Builds the search dialog to search for a concept or class. # @param self The object pointer # @param row the row to insert the result # @param column the column to insert the result # @param interlinkOrEnrich indicates if the dialog is meant for interlinking or enrichment # @param table the GUI element to display the result def buildSearchDialog(self, row, column, interlinkOrEnrich, table, propOrClass, bothOptions=False, currentprefixes=None, addVocabConf=None): self.currentcol = column self.currentrow = row self.interlinkdialog = SearchDialog(column, row, self.triplestoreconf, self.prefixes, interlinkOrEnrich, table, propOrClass, bothOptions, currentprefixes, addVocabConf) self.interlinkdialog.setMinimumSize(650, 400) self.interlinkdialog.setWindowTitle("Search Interlink Concept") self.interlinkdialog.exec_() ## # @brief Builds a boundingbox dialog allows to pick a bounding box for a SPARQL query. # # @param self The object pointer def getPointFromCanvas(self): self.d = BBOXDialog(self.inp_sparql2, self.triplestoreconf, self.comboBox.currentIndex()) self.d.setWindowTitle("Choose BoundingBox") self.d.exec_() ## # @brief Builds a value mapping dialog window for ther interlinking dialog. # # @param self The object pointer # @param row The row of the table for which to map the value # @param column The column of the table for which to map the value # @param table The table in which to save the value mapping result # @param layer The layer which is concerned by the enrichment oder interlinking def buildValueMappingDialog(self, row, column, interlinkOrEnrich, table, layer): self.currentcol = column self.currentrow = row valuemap = None if table.item(row, column) != None and table.item(row, column).text() != "": valuemap = table.item(row, column).data(1) self.interlinkdialog = ValueMappingDialog(column, row, self.triplestoreconf, interlinkOrEnrich, table, table.item(row, 3).text(), layer, valuemap) self.interlinkdialog.setMinimumSize(650, 400) self.interlinkdialog.setWindowTitle("Get Value Mappings for column " + table.item(row, 3).text()) self.interlinkdialog.exec_() ## # @brief Loads a QGIS layer for interlinking into the interlinking dialog. # # @param self The object pointer def loadLayerForInterlink(self): layers = QgsProject.instance().layerTreeRoot().children() selectedLayerIndex = self.chooseLayerInterlink.currentIndex() if len(layers) == 0: return layer = layers[selectedLayerIndex].layer() fieldnames = [field.name() for field in layer.fields()] while self.interlinkTable.rowCount() > 0: self.interlinkTable.removeRow(0) row = 0 self.interlinkTable.setHorizontalHeaderLabels([ "Export?", "IDColumn?", "GeoColumn?", "Column", "ColumnProperty", "PropertyType", "ColumnConcept", "ValueConcepts" ]) self.interlinkTable.setColumnCount(8) for field in fieldnames: item = QTableWidgetItem(field) item.setFlags(QtCore.Qt.ItemIsEnabled) item2 = QTableWidgetItem() item2.setCheckState(True) item3 = QTableWidgetItem() item3.setCheckState(False) item4 = QTableWidgetItem() item4.setCheckState(False) self.interlinkTable.insertRow(row) self.interlinkTable.setItem(row, 3, item) self.interlinkTable.setItem(row, 0, item2) self.interlinkTable.setItem(row, 1, item3) self.interlinkTable.setItem(row, 2, item4) cbox = QComboBox() cbox.addItem("Automatic") cbox.addItem("AnnotationProperty") cbox.addItem("DataProperty") cbox.addItem("ObjectProperty") cbox.addItem("SubClass") self.interlinkTable.setCellWidget(row, 5, cbox) currentRowCount = self.interlinkTable.rowCount() row += 1 ## # @brief Loads a QGIS layer for enrichment into the enrichment dialog. # # @param self The object pointer def loadLayerForEnrichment(self): layers = QgsProject.instance().layerTreeRoot().children() selectedLayerIndex = self.chooseLayerEnrich.currentIndex() if len(layers) == 0: return layer = layers[selectedLayerIndex].layer() self.enrichTableResult.hide() while self.enrichTableResult.rowCount() > 0: self.enrichTableResult.removeRow(0) self.enrichTable.show() self.addEnrichedLayerRowButton.setEnabled(True) fieldnames = [field.name() for field in layer.fields()] while self.enrichTable.rowCount() > 0: self.enrichTable.removeRow(0) row = 0 self.enrichTable.setColumnCount(9) self.enrichTable.setHorizontalHeaderLabels([ "Column", "EnrichmentConcept", "TripleStore", "Strategy", "content", "ID Column", "ID Property", "ID Domain", "Language" ]) for field in fieldnames: item = QTableWidgetItem(field) item.setFlags(QtCore.Qt.ItemIsEnabled) currentRowCount = self.enrichTable.rowCount() self.enrichTable.insertRow(row) self.enrichTable.setItem(row, 0, item) cbox = QComboBox() cbox.addItem("No Enrichment") cbox.addItem("Keep Local") cbox.addItem("Keep Remote") cbox.addItem("Replace Local") cbox.addItem("Merge") cbox.addItem("Ask User") cbox.addItem("Exclude") self.enrichTable.setCellWidget(row, 3, cbox) cbox = QComboBox() cbox.addItem("Enrich Value") cbox.addItem("Enrich URI") cbox.addItem("Enrich Both") self.enrichTable.setCellWidget(row, 4, cbox) cbox = QComboBox() for fieldd in fieldnames: cbox.addItem(fieldd) self.enrichTable.setCellWidget(row, 5, cbox) itemm = QTableWidgetItem( "http://www.w3.org/2000/01/rdf-schema#label") self.enrichTable.setItem(row, 6, itemm) itemm = QTableWidgetItem("") self.enrichTable.setItem(row, 7, itemm) itemm = QTableWidgetItem("") self.enrichTable.setItem(row, 8, itemm) celllayout = QHBoxLayout() upbutton = QPushButton("Up") removebutton = QPushButton("Remove", self) removebutton.clicked.connect(self.deleteEnrichRow) downbutton = QPushButton("Down") celllayout.addWidget(upbutton) celllayout.addWidget(downbutton) celllayout.addWidget(removebutton) w = QWidget() w.setLayout(celllayout) optitem = QTableWidgetItem() #self.enrichTable.setCellWidget(row,4,w) #self.enrichTable.setItem(row,3,cbox) row += 1 self.originalRowCount = row ## Fetch the currently loaded layers. # @param self The object pointer. def loadUnicornLayers(self): layers = QgsProject.instance().layerTreeRoot().children() # Populate the comboBox with names of all the loaded unicorn layers self.loadedLayers.clear() self.chooseLayerInterlink.clear() self.chooseLayerEnrich.clear() for layer in layers: ucl = layer.name() #if type(layer) == QgsMapLayer.VectorLayer: self.loadedLayers.addItem(layer.name()) self.chooseLayerInterlink.addItem(layer.name()) self.chooseLayerEnrich.addItem(layer.name())
class Dialog(QDialog, Ui_attr2BUGS): def __init__(self, iface, ml): """Constructor for the dialog. Args: iface: QgsInterface instance. """ QDialog.__init__(self, iface.mainWindow()) self.setupUi(self) self.setWindowTitle('Attributes to BUGS') self.ml = ml self.ids = [] self.polynum = self.ml.featureCount() self.model = QStandardItemModel(0, 1) self.listView.setModel(self.model) self.model.setHeaderData(0, Qt.Horizontal, 'Field') provider = self.ml.dataProvider() fields = provider.fields() for f in fields: item = QStandardItem(f.name()) item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled) item.setData(Qt.Unchecked, Qt.CheckStateRole) self.model.appendRow(item) self.control() self.pushButton.clicked.connect(self.konv) self.pushButton_2.clicked.connect(self.close) self.pushButton_3.clicked.connect(self.save) def konv(self): QApplication.setOverrideCursor(Qt.WaitCursor) self.plainTextEdit.clear() mod = min(self.ids) provider = self.ml.dataProvider() fields = provider.fields() lst = '#data\nlist(' for row in range(0, self.model.rowCount()): it = self.model.itemFromIndex(self.model.index(row, 0)) if it.checkState() == 2: fld = str(self.model.itemData(self.model.index(row, 0))[0]) var = fld + '=c(' ft = fields[row].type() if ft == 10: for ne in range(mod, self.polynum + mod): feat = QgsFeature() fiter = self.ml.getFeatures(QgsFeatureRequest(ne)) if fiter.nextFeature(feat): u = feat.attribute(fld) var += "'%s'," % u var = var[:-2] + "')" else: for ne in range(mod, self.polynum + mod): feat = QgsFeature() fiter = self.ml.getFeatures(QgsFeatureRequest(ne)) if fiter.nextFeature(feat): u = feat.attribute(fld) var += "%s," % u var = var[:-1] + ')' lst += var + ', ' lst += ')' lst = lst.replace('), )', '))') self.plainTextEdit.appendPlainText(lst) QApplication.restoreOverrideCursor() def control(self): feat = QgsFeature() provider = self.ml.dataProvider() feats = provider.getFeatures() #self.emit(SIGNAL("runStatus(PyQt_PyObject)"), 0) #self.emit(SIGNAL("runRange(PyQt_PyObject)"), (0, self.polynum)) ne = 0 while feats.nextFeature(feat): ne += 1 #self.emit(SIGNAL("runStatus(PyQt_PyObject)"), ne) self.ids.append(feat.id()) def save(self): fileName, _ = QFileDialog.getSaveFileName(self, caption='Save As...') try: file = QFile(fileName + '.txt') file.open(QIODevice.WriteOnly | QIODevice.Text) out = QTextStream(file) out << self.plainTextEdit.toPlainText() out.flush() file.close() self.close() return True except IOError: return False
class ResourceSharingDialog(QDialog, FORM_CLASS): TAB_ALL = 0 TAB_INSTALLED = 1 TAB_SETTINGS = 2 def __init__(self, parent=None, iface=None): """Constructor. :param parent: Optional widget to use as parent :type parent: QWidget :param iface: An instance of QGisInterface :type iface: QGisInterface """ super(ResourceSharingDialog, self).__init__(parent) self.setupUi(self) self.iface = iface # Reconfigure UI self.setModal(True) self.button_edit.setEnabled(False) self.button_delete.setEnabled(False) self.button_install.setEnabled(False) self.button_open.setEnabled(False) self.button_uninstall.setEnabled(False) # Set up the "main menu" - QListWidgetItem # All collections icon_all = QIcon() icon_all.addFile(str(resources_path("img", "plugin.svg")), QSize(), QIcon.Normal, QIcon.Off) item_all = QListWidgetItem() item_all.setIcon(icon_all) item_all.setText(self.tr("All collections")) # Installed collections icon_installed = QIcon() icon_installed.addFile( str(resources_path("img", "plugin-installed.svg")), QSize(), QIcon.Normal, QIcon.Off, ) item_installed = QListWidgetItem() item_installed.setIcon(icon_installed) item_installed.setText(self.tr("Installed collections")) item_all.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled) # Settings / repositories icon_settings = QIcon() icon_settings.addFile(str(resources_path("img", "settings.svg")), QSize(), QIcon.Normal, QIcon.Off) item_settings = QListWidgetItem() item_settings.setIcon(icon_settings) item_settings.setText(self.tr("Settings")) item_all.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled) # Add the items to the list widget self.menu_list_widget.addItem(item_all) self.menu_list_widget.addItem(item_installed) self.menu_list_widget.addItem(item_settings) # Init the message bar self.message_bar = QgsMessageBar(self) self.message_bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed) self.vlayoutRightColumn.insertWidget(0, self.message_bar) # Progress dialog for long running processes self.progress_dialog = None # Init the repository manager dialog self.repository_manager = RepositoryManager() self.collection_manager = CollectionManager() # Collections list view self.collections_model = QStandardItemModel(0, 1) self.collections_model.sort(0, Qt.AscendingOrder) self.collection_proxy = CustomSortFilterProxyModel(self) self.collection_proxy.setSourceModel(self.collections_model) self.list_view_collections.setModel(self.collection_proxy) # Active selected collection self._sel_coll_id = None # Slots self.button_add.clicked.connect(self.add_repository) self.button_edit.clicked.connect(self.edit_repository) self.button_delete.clicked.connect(self.delete_repository) self.button_reload.clicked.connect(self.reload_repositories) self.button_reload_dir.clicked.connect(self.reload_off_res_directory) self.menu_list_widget.currentRowChanged.connect(self.set_current_tab) self.list_view_collections.selectionModel().currentChanged.connect( self.on_list_view_collections_clicked) self.line_edit_filter.textChanged.connect(self.filter_collections) self.button_install.clicked.connect(self.install_collection) self.button_open.clicked.connect(self.open_collection) self.button_uninstall.clicked.connect(self.uninstall_collection) self.button_box.button(QDialogButtonBox.Help).clicked.connect( self.open_help) # Populate the repositories widget and collections list view self.populate_repositories_widget() self.reload_collections_model() def set_current_tab(self, index): """Set stacked widget based on the active tab. :param index: The index of the active widget (in the list widget). :type index: int """ # Clear message bar self.message_bar.clearWidgets() if index == (self.menu_list_widget.count() - 1): # Last menu entry - Settings self.stacked_menu_widget.setCurrentIndex(1) else: # Not settings, must be Collections (all or installed) if index == 1: # Installed collections self.collection_proxy.accepted_status = COLLECTION_INSTALLED_STATUS # Set the web view title = self.tr("Installed Collections") description = self.tr( "On the left you see the list of all the " "installed collections.") else: # All collections (0) self.collection_proxy.accepted_status = COLLECTION_ALL_STATUS # Set the web view title = self.tr("All Collections") description = self.tr( "On the left you see a list of all the collections " "that are available from the registered repositories.<br> " "Installed collections are emphasized (in <b>bold</b>).") context = { "resources_path": str(resources_path()), "title": title, "description": description, } self.web_view_details.setHtml( render_template("tab_description.html", context)) self.stacked_menu_widget.setCurrentIndex(0) def add_repository(self): """Open add repository dialog.""" dlg = ManageRepositoryDialog(self) if not dlg.exec_(): return for repoName, repo in self.repository_manager.directories.items(): if dlg.line_edit_url.text().strip() == repo["url"]: self.message_bar.pushMessage( self.tr( "Unable to add another repository with the same URL!"), Qgis.Warning, 5, ) return if dlg.line_edit_name.text().strip() == repoName: self.message_bar.pushMessage( self.tr("Repositories must have unique names!"), Qgis.Warning, 5) return repo_name = dlg.line_edit_name.text() repo_url = dlg.line_edit_url.text().strip() repo_auth_cfg = dlg.line_edit_auth_id.text().strip() if repo_name in self.repository_manager.directories: repo_name += "(2)" # Show progress dialog self.show_progress_dialog("Fetching repository's metadata") # Add repository try: status, adderror = self.repository_manager.add_directory( repo_name, repo_url, repo_auth_cfg) if status: self.message_bar.pushMessage( self.tr("Repository was successfully added"), Qgis.Success, 5) else: self.message_bar.pushMessage( self.tr("Unable to add repository: %s") % adderror, Qgis.Warning, 5) except Exception as e: self.message_bar.pushMessage(self.tr("%s") % e, Qgis.Warning, 5) finally: self.progress_dialog.hide() # Reload data and widget self.reload_data_and_widget() # Deactivate edit and delete button self.button_edit.setEnabled(False) self.button_delete.setEnabled(False) def edit_repository(self): """Open edit repository dialog.""" selected_item = self.tree_repositories.currentItem() if selected_item: repo_name = selected_item.text(0) if not repo_name: return # Check if it is among the officially approved QGIS repositories settings = QgsSettings() settings.beginGroup(repo_settings_group()) if (settings.value(repo_name + "/url") in self.repository_manager._online_directories.values()): self.message_bar.pushMessage( self.tr("You can not edit the official repositories!"), Qgis.Warning, 5) return dlg = ManageRepositoryDialog(self) dlg.line_edit_name.setText(repo_name) dlg.line_edit_url.setText( self.repository_manager.directories[repo_name]["url"]) dlg.line_edit_auth_id.setText( self.repository_manager.directories[repo_name]["auth_cfg"]) if not dlg.exec_(): return # Check if the changed URL is already present and that # the new repository name is unique new_url = dlg.line_edit_url.text().strip() old_url = self.repository_manager.directories[repo_name]["url"] new_name = dlg.line_edit_name.text().strip() for repoName, repo in self.repository_manager.directories.items(): if new_url == repo["url"] and (old_url != new_url): self.message_bar.pushMessage( self.tr("Unable to add another repository with the same " "URL!"), Qgis.Warning, 5, ) return if new_name == repoName and (repo_name != new_name): self.message_bar.pushMessage( self.tr("Repositories must have unique names!"), Qgis.Warning, 5) return # Redundant if (new_name in self.repository_manager.directories) and (new_name != repo_name): new_name += "(2)" new_auth_cfg = dlg.line_edit_auth_id.text() # Show progress dialog self.show_progress_dialog("Fetching repository's metadata") # Edit repository try: status, editerror = self.repository_manager.edit_directory( repo_name, new_name, old_url, new_url, new_auth_cfg) if status: self.message_bar.pushMessage( self.tr("Repository is successfully updated"), Qgis.Success, 5) else: self.message_bar.pushMessage( self.tr("Unable to edit repository: %s") % editerror, Qgis.Warning, 5, ) except Exception as e: self.message_bar.pushMessage(self.tr("%s") % e, Qgis.Warning, 5) finally: self.progress_dialog.hide() # Reload data and widget self.reload_data_and_widget() # Deactivate the edit and delete buttons self.button_edit.setEnabled(False) self.button_delete.setEnabled(False) def delete_repository(self): """Delete a repository in the tree widget.""" selected_item = self.tree_repositories.currentItem() if selected_item: repo_name = selected_item.text(0) if not repo_name: return # Check if it is among the offical repositories repo_url = self.repository_manager.directories[repo_name]["url"] if repo_url in self.repository_manager._online_directories.values(): self.message_bar.pushMessage( self.tr("You can not remove official repositories!"), Qgis.Warning, 5) return warning = (self.tr("Are you sure you want to remove the following " "repository?") + "\n" + repo_name) if (QMessageBox.warning( self, self.tr("QGIS Resource Sharing"), warning, QMessageBox.Yes, QMessageBox.No, ) == QMessageBox.No): return # Remove repository installed_collections = self.collection_manager.get_installed_collections( repo_url) if installed_collections: message = ("You have installed collections from this " "repository. Please uninstall them first!") self.message_bar.pushMessage(message, Qgis.Warning, 5) else: self.repository_manager.remove_directory(repo_name) # Reload data and widget self.reload_data_and_widget() # Deactivate the edit and delete buttons self.button_edit.setEnabled(False) self.button_delete.setEnabled(False) def reload_off_res_directory(self): """Slot called when the user clicks the 'Reload directory' button.""" # Show progress dialog self.show_progress_dialog("Reloading the official QGIS resource" " directory") self.repository_manager._online_directories = {} # Registered directories self.repository_manager._directories = {} self.repository_manager.fetch_online_directories() # Load directory of repositories from settings self.repository_manager.load_directories() self.message_bar.pushMessage("On-line directory reloaded", Qgis.Info, 5) self.progress_dialog.hide() # Reload data and widget self.reload_data_and_widget() def reload_repositories(self): """Slot called when the user clicks the 'Reload repositories' button.""" # Show progress dialog self.show_progress_dialog("Reloading all repositories") for repo_name in self.repository_manager.directories: directory = self.repository_manager.directories[repo_name] url = directory["url"] auth_cfg = directory["auth_cfg"] try: status, reloaderror = self.repository_manager.reload_directory( repo_name, url, auth_cfg) if status: self.message_bar.pushMessage( self.tr("Repository %s is successfully reloaded") % repo_name, Qgis.Info, 5, ) else: self.message_bar.pushMessage( self.tr("Unable to reload %s: %s") % (repo_name, reloaderror), Qgis.Warning, 5, ) except Exception as e: self.message_bar.pushMessage( self.tr("%s") % e, Qgis.Warning, 5) self.progress_dialog.hide() # Reload data and widget self.reload_data_and_widget() def install_collection(self): """Slot called when the user clicks the Install/Reinstall button.""" # Save the current index to enable selection after installation self.current_index = self.list_view_collections.currentIndex() self.show_progress_dialog("Starting installation...") self.progress_dialog.canceled.connect(self.install_canceled) self.installer_thread = QThread() self.installer_worker = CollectionInstaller(self.collection_manager, self._sel_coll_id) self.installer_worker.moveToThread(self.installer_thread) self.installer_worker.finished.connect(self.install_finished) self.installer_worker.aborted.connect(self.install_aborted) self.installer_worker.progress.connect(self.install_progress) self.installer_thread.started.connect(self.installer_worker.run) self.installer_thread.start() def install_finished(self): # Process the result self.progress_dialog.hide() installStatus = self.installer_worker.install_status if not installStatus: message = self.installer_worker.error_message # Clean up the worker and thread self.installer_worker.deleteLater() self.installer_thread.quit() self.installer_thread.wait() self.installer_thread.deleteLater() if installStatus: self.reload_collections_model() # Report what has been installed message = "<b>%s</b> was successfully installed, " "containing:\n<ul>" % ( config.COLLECTIONS[self._sel_coll_id]["name"]) number = 0 for type_, description in SUPPORTED_RESOURCES_MAP.items(): if type_ in config.COLLECTIONS[self._sel_coll_id].keys(): number = config.COLLECTIONS[self._sel_coll_id][type_] message += (f"\n<li>{number} {description}" f'{"s" if number > 1 else ""}' f"</li>") message += "\n</ul>" QMessageBox.information(self, "Resource Sharing", message) self.populate_repositories_widget() # Set the selection oldRow = self.current_index.row() newIndex = self.collections_model.createIndex(oldRow, 0) selection_model = self.list_view_collections.selectionModel() selection_model.setCurrentIndex(newIndex, selection_model.ClearAndSelect) selection_model.select(newIndex, selection_model.ClearAndSelect) # Update the buttons self.button_install.setEnabled(True) self.button_install.setText("Reinstall") self.button_open.setEnabled(True) self.button_uninstall.setEnabled(True) self.show_collection_metadata(self._sel_coll_id) def install_canceled(self): self.progress_dialog.hide() self.show_progress_dialog("Cancelling installation...") self.installer_worker.abort() def install_aborted(self): if self.installer_thread.isRunning(): self.installer_thread.quit() self.installer_thread.finished.connect(self.progress_dialog.hide) def install_progress(self, text): self.progress_dialog.setLabelText(text) def uninstall_collection(self): """Slot called when the user clicks the 'Uninstall' button.""" # get the QModelIndex for the item to be uninstalled uninstall_index = self.list_view_collections.currentIndex() coll_id = self._sel_coll_id try: self.collection_manager.uninstall(coll_id) except Exception as e: LOGGER.error("Could not uninstall collection " + config.COLLECTIONS[coll_id]["name"] + ":\n" + str(e)) else: QMessageBox.information( self, "Resource Sharing", "The collection was successfully uninstalled!") self.reload_collections_model() # Fix the GUI currentMenuRow = self.menu_list_widget.currentRow() self.set_current_tab(currentMenuRow) self.populate_repositories_widget() rowCount = self.collection_proxy.rowCount() if rowCount > 0: # Set the current (and selected) row in the listview newRow = uninstall_index.row() # Check if this was the last element rowCount = self.collection_proxy.rowCount() if newRow == rowCount: newRow = newRow - 1 # Select the new current element newIndex = self.collections_model.createIndex(newRow, 0) selection_model = self.list_view_collections.selectionModel() selection_model.setCurrentIndex(newIndex, selection_model.ClearAndSelect) # Get the id of the current collection proxyModel = self.list_view_collections.model() proxyIndex = proxyModel.index(newRow, 0) current_coll_id = proxyIndex.data(COLLECTION_ID_ROLE) self._sel_coll_id = current_coll_id # Update buttons status = config.COLLECTIONS[current_coll_id]["status"] if status == COLLECTION_INSTALLED_STATUS: self.button_install.setEnabled(True) self.button_install.setText("Reinstall") self.button_open.setEnabled(True) self.button_uninstall.setEnabled(True) else: self.button_install.setEnabled(True) self.button_install.setText("Install") self.button_open.setEnabled(False) self.button_uninstall.setEnabled(False) # Update the web_view_details frame self.show_collection_metadata(current_coll_id) else: self.button_install.setEnabled(False) self.button_install.setText("Install") self.button_open.setEnabled(False) self.button_uninstall.setEnabled(False) def open_collection(self): """Slot called when the user clicks the 'Open' button.""" collection_path = local_collection_path(self._sel_coll_id) directory_url = QUrl.fromLocalFile(str(collection_path)) QDesktopServices.openUrl(directory_url) def reload_data_and_widget(self): """Reload repositories and collections and update widgets related.""" self.reload_repositories_widget() self.reload_collections_model() def reload_repositories_widget(self): """Refresh tree repositories using new repositories data.""" self.repository_manager.load_directories() self.populate_repositories_widget() def populate_repositories_widget(self): """Populate the current dictionary repositories to the tree widget.""" # Clear the current tree widget self.tree_repositories.clear() installed_collections = self.collection_manager.get_installed_collections( ) # Export the updated ones from the repository manager repo_Font = QFont() repo_with_installed_Font = QFont() repo_with_installed_Font.setWeight(60) collection_brush = QBrush(Qt.darkGray) installed_collection_brush = QBrush(QColor(60, 25, 10)) for repo_name in self.repository_manager.directories: url = self.repository_manager.directories[repo_name]["url"] item = QTreeWidgetItem(self.tree_repositories, REPOSITORY_ITEM) # Is the repository in the QGIS resource directory? if url in self.repository_manager._online_directories.values(): repo_with_installed_Font.setUnderline(True) repo_Font.setUnderline(True) else: repo_with_installed_Font.setUnderline(False) repo_Font.setUnderline(False) item.setText(0, repo_name) item.setText(1, url) item.setFont(0, repo_Font) for coll_id in config.COLLECTIONS: if ("repository_name" in config.COLLECTIONS[coll_id].keys() and config.COLLECTIONS[coll_id]["repository_name"] == repo_name): coll_name = config.COLLECTIONS[coll_id]["name"] coll_tags = config.COLLECTIONS[coll_id]["tags"] collectionItem = QTreeWidgetItem(item, COLLECTION_ITEM) brush = collection_brush collectionFont = QFont() collectionFont.setStyle(QFont.StyleItalic) collitemtext = coll_name if (installed_collections and coll_id in installed_collections.keys()): collitemtext = coll_name + " (installed)" brush = installed_collection_brush item.setFont(0, repo_with_installed_Font) item.setForeground(0, brush) item.setForeground(1, brush) collectionItem.setFont(0, collectionFont) collectionItem.setForeground(0, brush) collectionItem.setText(0, collitemtext) collectionItem.setFont(1, collectionFont) collectionItem.setForeground(1, brush) collectionItem.setText(1, coll_tags) self.tree_repositories.resizeColumnToContents(0) self.tree_repositories.resizeColumnToContents(1) self.tree_repositories.sortItems(1, Qt.AscendingOrder) def reload_collections_model(self): """Reload the collections model with the current collections.""" self.collections_model.clear() installed_collections = self.collection_manager.get_installed_collections( ) for id in config.COLLECTIONS: collection_name = config.COLLECTIONS[id]["name"] collection_author = config.COLLECTIONS[id]["author"] collection_tags = config.COLLECTIONS[id]["tags"] collection_description = config.COLLECTIONS[id]["description"] collection_status = config.COLLECTIONS[id]["status"] repository_name = "" if "repository_name" in config.COLLECTIONS[id].keys(): repository_name = config.COLLECTIONS[id]["repository_name"] item = QStandardItem(collection_name + " (" + repository_name + ")") item.setEditable(False) item.setData(id, COLLECTION_ID_ROLE) item.setData(collection_name, COLLECTION_NAME_ROLE) item.setData(collection_description, COLLECTION_DESCRIPTION_ROLE) item.setData(collection_author, COLLECTION_AUTHOR_ROLE) item.setData(collection_tags, COLLECTION_TAGS_ROLE) item.setData(collection_status, COLLECTION_STATUS_ROLE) # Make installed collections stand out if installed_collections and id in installed_collections.keys(): collectionFont = QFont() collectionFont.setWeight(60) item.setFont(collectionFont) self.collections_model.appendRow(item) self.collections_model.sort(0, Qt.AscendingOrder) def on_tree_repositories_itemSelectionChanged(self): """Slot for the itemSelectionChanged signal of tree_repositories.""" selected_item = self.tree_repositories.currentItem() if selected_item and selected_item.type() == REPOSITORY_ITEM: if selected_item: repo_name = selected_item.text(0) if not repo_name: return if repo_name not in self.repository_manager.directories.keys(): return repo_url = self.repository_manager.directories[repo_name]["url"] # Disable the edit and delete buttons for "official" repositories if repo_url in self.repository_manager._online_directories.values( ): self.button_edit.setEnabled(False) self.button_delete.setEnabled(False) else: # Activate the edit and delete buttons self.button_edit.setEnabled(True) self.button_delete.setEnabled(True) elif selected_item and selected_item.type() == COLLECTION_ITEM: self.button_edit.setEnabled(False) self.button_delete.setEnabled(False) else: self.button_edit.setEnabled(False) self.button_delete.setEnabled(False) def on_list_view_collections_clicked(self, index): """Slot called when the user clicks an item in list_view_collections.""" real_index = self.collection_proxy.mapToSource(index) if real_index.row() != -1: collection_item = self.collections_model.itemFromIndex(real_index) collection_id = collection_item.data(COLLECTION_ID_ROLE) self._sel_coll_id = collection_id # Enable / disable buttons status = config.COLLECTIONS[self._sel_coll_id]["status"] is_installed = status == COLLECTION_INSTALLED_STATUS if is_installed: self.button_install.setEnabled(True) self.button_install.setText("Reinstall") self.button_open.setEnabled(True) self.button_uninstall.setEnabled(True) else: self.button_install.setEnabled(True) self.button_install.setText("Install") self.button_open.setEnabled(False) self.button_uninstall.setEnabled(False) # Show metadata self.show_collection_metadata(collection_id) @pyqtSlot(str) def filter_collections(self, text): search = QRegExp(text, Qt.CaseInsensitive, QRegExp.RegExp) self.collection_proxy.setFilterRegExp(search) def show_collection_metadata(self, id): """Show the collection metadata given the ID.""" html = self.collection_manager.get_html(id) self.web_view_details.setHtml(html) def reject(self): """Slot called when the dialog is closed.""" # Serialize collections to settings self.repository_manager.serialize_repositories() self.done(0) def open_help(self): """Open help.""" doc_url = QUrl("http://qgis-contribution.github.io/" + "QGIS-ResourceSharing/") QDesktopServices.openUrl(doc_url) def show_progress_dialog(self, text): """Show infinite progress dialog with given text. :param text: Text as the label of the progress dialog :type text: str """ if self.progress_dialog is None: self.progress_dialog = QProgressDialog(self) self.progress_dialog.setWindowModality(Qt.WindowModal) self.progress_dialog.setAutoClose(False) title = self.tr("Resource Sharing") self.progress_dialog.setWindowTitle(title) # Just use an infinite progress bar here self.progress_dialog.setMaximum(0) self.progress_dialog.setMinimum(0) self.progress_dialog.setValue(0) self.progress_dialog.setLabelText(text) self.progress_dialog.show()
class QRAVEMetaWidget(QDockWidget, Ui_QRAVEMetaWidgetBase): def __init__(self, parent=None): """Constructor.""" super(QRAVEMetaWidget, self).__init__(parent) self.setupUi(self) self.treeView.setContextMenuPolicy(Qt.CustomContextMenu) self.treeView.customContextMenuRequested.connect(self.open_menu) self.treeView.doubleClicked.connect(self.default_tree_action) self.settings = Settings() self.model = QStandardItemModel() self.treeView.setModel(self.model) self.meta = None self.menu = QMenu() # Initialize our classes self.hide() @pyqtSlot(str, str, dict, bool) def load(self, label: str, meta_type: str, meta: dict, show: bool = False): # re-initialize our model self.model.clear() self.meta = meta root_item = self.model.invisibleRootItem() self.model.setColumnCount(2) self.model.setHorizontalHeaderLabels(['Meta Name', 'Meta Value']) if meta_type == MetaType.PROJECT: self.treeView.setHeaderHidden(False) self.setWindowTitle('Project MetaData: {}'.format(label)) self.treeView.setEnabled(True) if meta is not None and len(meta.keys()) > 0: if 'project' in meta and len(meta['project'].keys()) > 0: proj_meta = QStandardItem('Project Meta') proj_meta_font = proj_meta.font() proj_meta_font.setBold(True) proj_meta.setFont(proj_meta_font) for k, v in meta['project'].items(): proj_meta.appendRow( [QStandardItem(k), QStandardItem(v)]) root_item.appendRow(proj_meta) if 'warehouse' in meta and len(meta['warehouse'].keys()) > 0: wh_meta = QStandardItem('Warehouse Meta') wh_meta_font = proj_meta.font() wh_meta_font.setBold(True) wh_meta.setFont(wh_meta_font) for k, v in meta['warehouse'].items(): wh_meta.appendRow([QStandardItem(k), QStandardItem(v)]) root_item.appendRow(wh_meta) elif meta_type == MetaType.FOLDER: self.setWindowTitle('Folder: {}'.format(label)) self.treeView.setHeaderHidden(True) self.treeView.setEnabled(False) self.model.setColumnCount(1) self.model.setHorizontalHeaderLabels(['Meta Name']) no_item = QStandardItem('Folders have no MetaData') no_item.setTextAlignment(Qt.AlignCenter) no_f = no_item.font() no_f.setItalic(True) no_item.setFont(no_f) root_item.appendRow(no_item) elif meta_type == MetaType.LAYER: self.setWindowTitle('Layer MetaData: {}'.format(label)) self.treeView.setEnabled(True) self.treeView.setHeaderHidden(False) if meta is not None and len(meta.keys()) > 0: for k, v in meta.items(): root_item.appendRow([QStandardItem(k), QStandardItem(v)]) else: self.treeView.setHeaderHidden(True) self.treeView.setEnabled(False) self.model.setColumnCount(1) self.model.setHorizontalHeaderLabels(['Meta Name']) no_item = QStandardItem('This layer has no MetaData') no_item.setTextAlignment(Qt.AlignCenter) no_f = no_item.font() no_f.setItalic(True) no_item.setFont(no_f) root_item.appendRow(no_item) elif meta_type == MetaType.NONE: self.treeView.setHeaderHidden(True) self.treeView.setEnabled(False) self.model.setColumnCount(1) self.setWindowTitle('Riverscapes MetaData: {}'.format(label)) no_item = QStandardItem('This item cannot have metadata') no_item.setTextAlignment(Qt.AlignCenter) no_f = no_item.font() no_f.setItalic(True) no_item.setFont(no_f) root_item.appendRow(no_item) return # self.tree.header().setDefaultSectionSize(180) # self._populateTree(self.tree, ) # Finally expand all levels self.treeView.expandAll() if show is True: self.show() def closeEvent(self, event): self.hide() def default_tree_action(self, index): item = self.model.itemFromIndex(index) data = item.data(Qt.UserRole) def open_menu(self, position): indexes = self.treeView.selectedIndexes() if len(indexes) < 1 or self.meta is None or len(self.meta.keys()) == 0: return # No multiselect so there is only ever one item item_name = self.model.itemFromIndex(indexes[0]) item_val = self.model.itemFromIndex( indexes[1]) if len(indexes) > 0 else None self.menu.clear() if item_val is not None: row_text = {item_name.text(): item_val.text()} self.menu.addAction('Copy Name to Clipboard', lambda: self.copy(item_name.text())) self.menu.addAction('Copy Value to Clipboard', lambda: self.copy(item_val.text())) self.menu.addAction( 'Copy Row to Clipboard (json)', lambda: self.copy( json.dumps(row_text, indent=4, sort_keys=True))) self.menu.addAction( 'Copy All to Clipboard (json)', lambda: self.copy(json.dumps(self.meta, indent=4, sort_keys=True))) self.menu.exec_(self.treeView.viewport().mapToGlobal(position)) def copy(self, data: str): cb = QGuiApplication.clipboard() cb.clear(mode=cb.Clipboard) cb.setText(data, mode=cb.Clipboard)
class TemplateDocumentSelector(WIDGET, BASE): """ Dialog for selecting a document template from the saved list. """ def __init__(self, parent=None, selectMode=True, filter_data_source='', access_templates=None): QDialog.__init__(self, parent) self.setupUi(self) self.notifBar = NotificationBar(self.vlNotification) self._mode = selectMode # Filter templates by the specified table name self._filter_data_source = filter_data_source # Document templates in current profile self._profile_templates = [] self._current_profile = current_profile() # Load current profile templates self._load_current_profile_templates() self.access_templates = access_templates or [] if selectMode: self.buttonBox.setVisible(True) self.manageButtonBox.setVisible(False) currHeight = self.size().height() self.resize(200, currHeight) else: self.buttonBox.setVisible(False) self.manageButtonBox.setVisible(True) self.setWindowTitle( QApplication.translate("TemplateDocumentSelector", "Template Manager")) # Configure manage buttons btnEdit = self.manageButtonBox.button(QDialogButtonBox.Ok) btnEdit.setText( QApplication.translate("TemplateDocumentSelector", "Edit...")) btnEdit.setIcon(GuiUtils.get_icon("edit.png")) btnDelete = self.manageButtonBox.button(QDialogButtonBox.Save) btnDelete.setText( QApplication.translate("TemplateDocumentSelector", "Delete")) btnDelete.setIcon(GuiUtils.get_icon("delete.png")) # Connect signals self.buttonBox.accepted.connect(self.onAccept) btnEdit.clicked.connect(self.onEditTemplate) btnDelete.clicked.connect(self.onDeleteTemplate) # Get saved document templates then add to the model templates = documentTemplates() self._docItemModel = QStandardItemModel(parent) self._docItemModel.setColumnCount(2) # Append current profile templates to the model. for dt in self._profile_templates: if self._template_contains_filter_table( dt): # and dt.name in self.access_templates: doc_name_item = self._createDocNameItem(dt.name) file_path_item = QStandardItem(dt.path) self._docItemModel.appendRow([doc_name_item, file_path_item]) self.lstDocs.setModel(self._docItemModel) def _load_current_profile_templates(self): # Loads only those templates that refer to tables in the current # profile. if self._current_profile is None: return # Get saved document templates then add to the model templates = documentTemplates() profile_tables = self._current_profile.table_names() # Get templates for the current profile for name, path in templates.items(): doc_temp = DocumentTemplate.build_from_path(name, path) if doc_temp.data_source is None: continue # Assert data source is in the current profile if doc_temp.data_source.referenced_table_name in profile_tables or \ doc_temp.data_source.name() in user_non_profile_views(): self._add_doc_temp(doc_temp) # self._profile_templates.append(doc_temp) def _add_doc_temp(self, doc_temp): found = False for template in self._profile_templates: if template.name == doc_temp.name: found = True break if not found: self._profile_templates.append(doc_temp) def _template_contains_filter_table(self, document_template): # Returns true if the template refers to the filter data source # If no filter data source defined then always return True if document_template.data_source._dataSourceName in user_non_profile_views( ): return True if not self._filter_data_source: return True referenced_table = document_template.referenced_table_name if referenced_table == self._filter_data_source: return True return False @property def mode(self): return self._mode @property def filter_data_source(self): return self._filter_data_source def _createDocNameItem(self, docName): """ Create a template document standard item. """ # Set icon icon = QIcon() icon.addPixmap(GuiUtils.get_icon_pixmap("document.png"), QIcon.Normal, QIcon.Off) dnItem = QStandardItem(icon, docName) return dnItem def onEditTemplate(self): """ Slot raised to edit document template. """ self.notifBar.clear() if self.documentMapping() is None: self.notifBar.insertErrorNotification(QApplication.translate("TemplateDocumentSelector", \ "Please select a document template to edit")) return templateName, filePath = self.documentMapping() docName, ok = QInputDialog.getText(self, \ QApplication.translate("TemplateDocumentSelector", "Edit Template"), \ QApplication.translate("TemplateDocumentSelector", "Please enter the new template name below"), \ text=templateName) if ok and docName == "": self.notifBar.insertErrorNotification(QApplication.translate("TemplateDocumentSelector", \ "Template name cannot be empty")) return elif docName == templateName: return elif ok and docName != "": result, newTemplatePath = self._editTemplate(filePath, docName) if result: # Update view mIndices = self._selectedMappings() docNameItem = self._docItemModel.itemFromIndex(mIndices[0]) filePathItem = self._docItemModel.itemFromIndex(mIndices[1]) docNameItem.setText(docName) filePathItem.setText(newTemplatePath) self.notifBar.insertSuccessNotification(QApplication.translate("TemplateDocumentSelector", \ "'{0}' template has been successfully updated".format( docName))) else: self.notifBar.insertErrorNotification(QApplication.translate("TemplateDocumentSelector", \ "Error: '{0}' template could not be updated".format( templateName))) def onDeleteTemplate(self): """ Slot raised to delete document template. """ self.notifBar.clear() if self.documentMapping() == None: self.notifBar.insertErrorNotification(QApplication.translate("TemplateDocumentSelector", \ "Please select a document template to delete")) return templateName, filePath = self.documentMapping() result = QMessageBox.warning(self, QApplication.translate("TemplateDocumentSelector", \ "Confirm delete"), QApplication.translate("TemplateDocumentSelector", \ "Are you sure you want to delete '{0}' template?" \ "This action cannot be undone.\nClick Yes to proceed " \ "or No to cancel.".format(templateName)), QMessageBox.Yes | QMessageBox.No) if result == QMessageBox.No: return status = self._deleteDocument(filePath) if status: # Remove item from list using model index row number selectedDocNameIndices = self.lstDocs.selectionModel( ).selectedRows(0) row = selectedDocNameIndices[0].row() self._docItemModel.removeRow(row) self.notifBar.insertSuccessNotification(QApplication.translate("TemplateDocumentSelector", \ "'{0}' template has been successfully removed".format( templateName))) else: self.notifBar.insertErrorNotification(QApplication.translate("TemplateDocumentSelector", \ "Error: '{0}' template could not be removed".format( templateName))) def onAccept(self): """ Slot raised to close the dialog only when a selection has been made by the user. """ self.notifBar.clear() if self.documentMapping() == None: self.notifBar.insertErrorNotification(QApplication.translate("TemplateDocumentSelector", \ "Please select a document")) return self.accept() def _selectedMappings(self): """ Returns the model indices for the selected row. """ selectedDocNameIndices = self.lstDocs.selectionModel().selectedRows(0) selectedFilePathIndices = self.lstDocs.selectionModel().selectedRows(1) if len(selectedDocNameIndices) == 0: return None docNameIndex = selectedDocNameIndices[0] filePathIndex = selectedFilePathIndices[0] return (docNameIndex, filePathIndex) def documentMapping(self): """ Returns a tuple containing the selected document name and the corresponding file name. """ mIndices = self._selectedMappings() if mIndices == None: return None docNameItem = self._docItemModel.itemFromIndex(mIndices[0]) filePathItem = self._docItemModel.itemFromIndex(mIndices[1]) return (docNameItem.text(), filePathItem.text()) def _editTemplate(self, templatePath, newName): """ Updates the template document to use the new name. """ templateFile = QFile(templatePath) if not templateFile.open(QIODevice.ReadOnly): QMessageBox.critical(self, QApplication.translate("TemplateDocumentSelector", "Open Operation Error"), \ "{0}\n{1}".format( QApplication.translate("TemplateDocumentSelector", "Cannot read template file."), \ templateFile.errorString() )) return (False, "") templateDoc = QDomDocument() if templateDoc.setContent(templateFile): composerElement = templateDoc.documentElement() titleAttr = composerElement.attributeNode("_title") if not titleAttr.isNull(): titleAttr.setValue(newName) # Try remove file status = templateFile.remove() if not status: return (False, "") # Create new file newTemplatePath = self._composerTemplatesPath( ) + "/" + newName + ".sdt" newTemplateFile = QFile(newTemplatePath) if not newTemplateFile.open(QIODevice.WriteOnly): QMessageBox.critical(self, QApplication.translate("TemplateDocumentSelector", "Save Operation Error"), \ "{0}\n{1}".format(QApplication.translate("TemplateDocumentSelector", "Could not save template file."), \ newTemplateFile.errorString() )) return (False, "") if newTemplateFile.write(templateDoc.toByteArray()) == -1: QMessageBox.critical(self, QApplication.translate("TemplateDocumentSelector", "Save Error"), \ QApplication.translate("TemplateDocumentSelector", "Could not save template file.")) return (False, "") newTemplateFile.close() return (True, newTemplatePath) def _deleteDocument(self, templatePath): """ Delete the document template from the file system. """ docFile = QFile(templatePath) return docFile.remove() def _composerTemplatesPath(self): """ Reads the path of composer templates in the registry. """ regConfig = RegistryConfig() keyName = "ComposerTemplates" valueCollection = regConfig.read([keyName]) if len(valueCollection) == 0: return None else: return valueCollection[keyName]
class ResourceSharingDialog(QDialog, FORM_CLASS): TAB_ALL = 0 TAB_INSTALLED = 1 TAB_SETTINGS = 2 def __init__(self, parent=None, iface=None): """Constructor. :param parent: Optional widget to use as parent :type parent: QWidget :param iface: An instance of QGisInterface :type iface: QGisInterface """ super(ResourceSharingDialog, self).__init__(parent) self.setupUi(self) self.iface = iface # Reconfigure UI self.setModal(True) self.button_edit.setEnabled(False) self.button_delete.setEnabled(False) self.button_install.setEnabled(False) self.button_open.setEnabled(False) self.button_uninstall.setEnabled(False) # Set QListWidgetItem # All icon_all = QIcon() icon_all.addFile( resources_path('img', 'plugin.svg'), QSize(), QIcon.Normal, QIcon.Off) item_all = QListWidgetItem() item_all.setIcon(icon_all) item_all.setText(self.tr('All')) # Installed icon_installed = QIcon() icon_installed.addFile( resources_path('img', 'plugin-installed.svg'), QSize(), QIcon.Normal, QIcon.Off) item_installed = QListWidgetItem() item_installed.setIcon(icon_installed) item_installed.setText(self.tr('Installed')) item_all.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled) # Settings icon_settings = QIcon() icon_settings.addFile( resources_path('img', 'settings.svg'), QSize(), QIcon.Normal, QIcon.Off) item_settings = QListWidgetItem() item_settings.setIcon(icon_settings) item_settings.setText(self.tr('Settings')) item_all.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled) # Add the list widget item to the widget self.menu_list_widget.addItem(item_all) self.menu_list_widget.addItem(item_installed) self.menu_list_widget.addItem(item_settings) # Init the message bar self.message_bar = QgsMessageBar(self) self.message_bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed) self.vlayoutRightColumn.insertWidget(0, self.message_bar) # Progress dialog for any long running process self.progress_dialog = None # Init repository manager self.repository_manager = RepositoryManager() self.collection_manager = CollectionManager() # Collections list view self.collections_model = QStandardItemModel(0, 1) self.collections_model.sort(0, Qt.AscendingOrder) self.collection_proxy = CustomSortFilterProxyModel(self) self.collection_proxy.setSourceModel(self.collections_model) self.list_view_collections.setModel(self.collection_proxy) # Active selected collection self._selected_collection_id = None # Slots self.button_add.clicked.connect(self.add_repository) self.button_edit.clicked.connect(self.edit_repository) self.button_delete.clicked.connect(self.delete_repository) self.button_reload.clicked.connect(self.reload_repositories) self.menu_list_widget.currentRowChanged.connect(self.set_current_tab) self.list_view_collections.selectionModel().currentChanged.connect( self.on_list_view_collections_clicked) self.line_edit_filter.textChanged.connect(self.filter_collections) self.button_install.clicked.connect(self.install_collection) self.button_open.clicked.connect(self.open_collection) self.button_uninstall.clicked.connect(self.uninstall_collection) self.button_box.button(QDialogButtonBox.Help).clicked.connect( self.open_help) # Populate repositories widget and collections list view self.populate_repositories_widget() self.reload_collections_model() def set_current_tab(self, index): """Set stacked widget based on active tab. :param index: The index of the active list widget item. :type index: int """ # Clear message bar first self.message_bar.clearWidgets() if index == (self.menu_list_widget.count() - 1): # Switch to settings tab self.stacked_menu_widget.setCurrentIndex(1) else: # Switch to plugins tab if index == 1: # Installed self.collection_proxy.accepted_status = \ COLLECTION_INSTALLED_STATUS # Set the web view title = self.tr('Installed Collections') description = self.tr( 'On the left you see the list of all collections ' 'installed on your QGIS') else: # All self.collection_proxy.accepted_status = COLLECTION_ALL_STATUS # Set the web view title = self.tr('All Collections') description = self.tr( 'On the left you see the list of all collections ' 'available from the repositories registered in the ' 'settings.') context = { 'resources_path': resources_path(), 'title': title, 'description': description } self.web_view_details.setHtml( render_template('tab_description.html', context)) self.stacked_menu_widget.setCurrentIndex(0) def add_repository(self): """Open add repository dialog.""" dlg = ManageRepositoryDialog(self) if not dlg.exec_(): return for repo in self.repository_manager.directories.values(): if dlg.line_edit_url.text().strip() == repo['url']: self.message_bar.pushMessage( self.tr( 'Unable to add another repository with the same URL!'), Qgis.Critical, 5) return repo_name = dlg.line_edit_name.text() repo_url = dlg.line_edit_url.text().strip() repo_auth_cfg = dlg.line_edit_auth_id.text().strip() if repo_name in self.repository_manager.directories: repo_name += '(2)' # Show progress dialog self.show_progress_dialog("Fetching repository's metadata") # Add repository try: status, description = self.repository_manager.add_directory( repo_name, repo_url, repo_auth_cfg) if status: self.message_bar.pushMessage( self.tr( 'Repository is successfully added'), Qgis.Success, 5) else: self.message_bar.pushMessage( self.tr( 'Unable to add repository: %s') % description, Qgis.Critical, 5) except Exception as e: self.message_bar.pushMessage( self.tr('%s') % e, Qgis.Critical, 5) finally: self.progress_dialog.hide() # Reload data and widget self.reload_data_and_widget() # Deactivate edit and delete button self.button_edit.setEnabled(False) self.button_delete.setEnabled(False) def edit_repository(self): """Open edit repository dialog.""" selected_item = self.tree_repositories.currentItem() if selected_item: repo_name = selected_item.text(0) if not repo_name: return # Check if it's the approved online dir repository settings = QSettings() settings.beginGroup(repo_settings_group()) if settings.value(repo_name + '/url') in \ self.repository_manager._online_directories.values(): self.message_bar.pushMessage( self.tr( 'You can not edit the official repositories!'), Qgis.Warning, 5) return dlg = ManageRepositoryDialog(self) dlg.line_edit_name.setText(repo_name) dlg.line_edit_url.setText( self.repository_manager.directories[repo_name]['url']) dlg.line_edit_auth_id.setText( self.repository_manager.directories[repo_name]['auth_cfg']) if not dlg.exec_(): return # Check if the changed URL is already there in the repo new_url = dlg.line_edit_url.text().strip() old_url = self.repository_manager.directories[repo_name]['url'] for repo in self.repository_manager.directories.values(): if new_url == repo['url'] and (old_url != new_url): self.message_bar.pushMessage( self.tr('Unable to add another repository with the same ' 'URL!'), Qgis.Critical, 5) return new_name = dlg.line_edit_name.text() if (new_name in self.repository_manager.directories) and ( new_name != repo_name): new_name += '(2)' new_auth_cfg = dlg.line_edit_auth_id.text() # Show progress dialog self.show_progress_dialog("Fetching repository's metadata") # Edit repository try: status, description = self.repository_manager.edit_directory( repo_name, new_name, old_url, new_url, new_auth_cfg ) if status: self.message_bar.pushMessage( self.tr('Repository is successfully updated'), Qgis.Success, 5) else: self.message_bar.pushMessage( self.tr('Unable to add repository: %s') % description, Qgis.Critical, 5) except Exception as e: self.message_bar.pushMessage( self.tr('%s') % e, Qgis.Critical, 5) finally: self.progress_dialog.hide() # Reload data and widget self.reload_data_and_widget() # Deactivate edit and delete button self.button_edit.setEnabled(False) self.button_delete.setEnabled(False) def delete_repository(self): """Delete a repository in the tree widget.""" selected_item = self.tree_repositories.currentItem() if selected_item: repo_name = selected_item.text(0) if not repo_name: return # Check if it's the approved online dir repository repo_url = self.repository_manager.directories[repo_name]['url'] if repo_url in self.repository_manager._online_directories.values(): self.message_bar.pushMessage( self.tr( 'You can not remove the official repositories!'), Qgis.Warning, 5) return warning = self.tr('Are you sure you want to remove the following ' 'repository?') + '\n' + repo_name if QMessageBox.warning( self, self.tr('QGIS Resource Sharing'), warning, QMessageBox.Yes, QMessageBox.No) == QMessageBox.No: return # Remove repository installed_collections = \ self.collection_manager.get_installed_collections(repo_url) if installed_collections: message = ('You have some installed collections from this ' 'repository. Please uninstall them first!') self.message_bar.pushMessage(message, Qgis.Warning, 5) else: self.repository_manager.remove_directory(repo_name) # Reload data and widget self.reload_data_and_widget() # Deactivate edit and delete button self.button_edit.setEnabled(False) self.button_delete.setEnabled(False) def reload_repositories(self): """Slot for when user clicks reload repositories button.""" # Show progress dialog self.show_progress_dialog('Reloading all repositories') for repo_name in self.repository_manager.directories: directory = self.repository_manager.directories[repo_name] url = directory['url'] auth_cfg = directory['auth_cfg'] try: status, description = self.repository_manager.reload_directory( repo_name, url, auth_cfg) if status: self.message_bar.pushMessage( self.tr( 'Repository %s is successfully reloaded') % repo_name, Qgis.Info, 5) else: self.message_bar.pushMessage( self.tr( 'Unable to reload %s: %s') % ( repo_name, description), Qgis.Critical, 5) except Exception as e: self.message_bar.pushMessage( self.tr('%s') % e, Qgis.Critical, 5) self.progress_dialog.hide() # Reload data and widget self.reload_data_and_widget() def install_collection(self): """Slot for when user clicks download button.""" self.show_progress_dialog('Starting installation process...') self.progress_dialog.canceled.connect(self.install_canceled) self.installer_thread = QThread() self.installer_worker = CollectionInstaller( self.collection_manager, self._selected_collection_id) self.installer_worker.moveToThread(self.installer_thread) self.installer_worker.finished.connect(self.install_finished) self.installer_worker.aborted.connect(self.install_aborted) self.installer_worker.progress.connect(self.install_progress) self.installer_thread.started.connect(self.installer_worker.run) self.installer_thread.start() def install_finished(self): # Process the result self.progress_dialog.hide() if self.installer_worker.install_status: self.reload_collections_model() message = '%s is installed successfully' % ( config.COLLECTIONS[self._selected_collection_id]['name']) else: message = self.installer_worker.error_message QMessageBox.information(self, 'Resource Sharing', message) # Clean up the worker and thread self.installer_worker.deleteLater() self.installer_thread.quit() self.installer_thread.wait() self.installer_thread.deleteLater() def install_canceled(self): self.progress_dialog.hide() self.show_progress_dialog('Cancelling installation...') self.installer_worker.abort() def install_aborted(self): if self.installer_thread.isRunning(): self.installer_thread.quit() self.installer_thread.finished.connect(self.progress_dialog.hide) def install_progress(self, text): self.progress_dialog.setLabelText(text) def uninstall_collection(self): """Slot called when user clicks uninstall button.""" try: self.collection_manager.uninstall(self._selected_collection_id) except Exception as e: raise self.reload_collections_model() QMessageBox.information( self, 'Resource Sharing', 'The collection is uninstalled succesfully!') def open_collection(self): """Slot for when user clicks 'Open' button.""" collection_path = local_collection_path(self._selected_collection_id) directory_url = QUrl.fromLocalFile(collection_path) QDesktopServices.openUrl(directory_url) def reload_data_and_widget(self): """Reload repositories and collections and update widgets related.""" self.reload_repositories_widget() self.reload_collections_model() def reload_repositories_widget(self): """Refresh tree repositories using new repositories data.""" self.repository_manager.load_directories() self.populate_repositories_widget() def populate_repositories_widget(self): """Populate the current dictionary repositories to the tree widget.""" # Clear the current tree widget self.tree_repositories.clear() # Export the updated ones from the repository manager for repo_name in self.repository_manager.directories: url = self.repository_manager.directories[repo_name]['url'] item = QTreeWidgetItem(self.tree_repositories) item.setText(0, repo_name) item.setText(1, url) self.tree_repositories.resizeColumnToContents(0) self.tree_repositories.resizeColumnToContents(1) self.tree_repositories.sortItems(1, Qt.AscendingOrder) def reload_collections_model(self): """Reload the collections model with the current collections.""" self.collections_model.clear() for id in config.COLLECTIONS: collection_name = config.COLLECTIONS[id]['name'] collection_author = config.COLLECTIONS[id]['author'] collection_tags = config.COLLECTIONS[id]['tags'] collection_description = config.COLLECTIONS[id]['description'] collection_status = config.COLLECTIONS[id]['status'] item = QStandardItem(collection_name) item.setEditable(False) item.setData(id, COLLECTION_ID_ROLE) item.setData(collection_name, COLLECTION_NAME_ROLE) item.setData(collection_description, COLLECTION_DESCRIPTION_ROLE) item.setData(collection_author, COLLECTION_AUTHOR_ROLE) item.setData(collection_tags, COLLECTION_TAGS_ROLE) item.setData(collection_status, COLLECTION_STATUS_ROLE) self.collections_model.appendRow(item) self.collections_model.sort(0, Qt.AscendingOrder) def on_tree_repositories_itemSelectionChanged(self): """Slot for when the itemSelectionChanged signal emitted.""" # Activate edit and delete button self.button_edit.setEnabled(True) self.button_delete.setEnabled(True) def on_list_view_collections_clicked(self, index): """Slot for when the list_view_collections is clicked.""" real_index = self.collection_proxy.mapToSource(index) if real_index.row() != -1: collection_item = self.collections_model.itemFromIndex(real_index) collection_id = collection_item.data(COLLECTION_ID_ROLE) self._selected_collection_id = collection_id # Enable/disable button status = config.COLLECTIONS[self._selected_collection_id]['status'] is_installed = status == COLLECTION_INSTALLED_STATUS if is_installed: self.button_install.setEnabled(True) self.button_install.setText('Reinstall') self.button_open.setEnabled(True) self.button_uninstall.setEnabled(True) else: self.button_install.setEnabled(True) self.button_install.setText('Install') self.button_open.setEnabled(False) self.button_uninstall.setEnabled(False) # Show metadata self.show_collection_metadata(collection_id) @pyqtSlot(str) def filter_collections(self, text): search = QRegExp( text, Qt.CaseInsensitive, QRegExp.RegExp) self.collection_proxy.setFilterRegExp(search) def show_collection_metadata(self, id): """Show the collection metadata given the id.""" html = self.collection_manager.get_html(id) self.web_view_details.setHtml(html) def reject(self): """Slot when the dialog is closed.""" # Serialize collections to settings self.repository_manager.serialize_repositories() self.done(0) def open_help(self): """Open help.""" doc_url = QUrl('http://www.akbargumbira.com/qgis_resources_sharing') QDesktopServices.openUrl(doc_url) def show_progress_dialog(self, text): """Show infinite progress dialog with given text. :param text: Text as the label of the progress dialog :type text: str """ if self.progress_dialog is None: self.progress_dialog = QProgressDialog(self) self.progress_dialog.setWindowModality(Qt.WindowModal) self.progress_dialog.setAutoClose(False) title = self.tr('Resource Sharing') self.progress_dialog.setWindowTitle(title) # Just use infinite progress bar here self.progress_dialog.setMaximum(0) self.progress_dialog.setMinimum(0) self.progress_dialog.setValue(0) self.progress_dialog.setLabelText(text) self.progress_dialog.show()
class manageAccountsDlg(WIDGET, BASE): ''' User- and Role-management dialog class ''' def __init__(self, plugin): QDialog.__init__(self, plugin.iface.mainWindow()) self.setupUi(self) QgsGui.enableAutoGeometryRestore(self) self.tbUserRole.setTabIcon(0, GuiUtils.get_icon('user.png')) self.tbUserRole.setTabIcon(1, GuiUtils.get_icon('roles.png')) self.tbUserRole.setTabIcon(2, GuiUtils.get_icon('user_mapping.png')) # Initialize the dialog self.initGui() # Load users self.loadUsers() # Load Roles self.loadRoles() # Load user mappings self.loadUserMappings() # Reference to the currently selected STDM role for which user mappings need to be defined self.currentRole = None def initGui(self): ''' Set control properties ''' # Set properties for 'Users' button box btnUserNew = self.btnManageUsers.button(QDialogButtonBox.Ok) btnUserNew.setText(QApplication.translate("manageAccountsDlg", "New") + "...") btnUserNew.clicked.connect(self.onNewUser) btnUserEdit = self.btnManageUsers.button(QDialogButtonBox.Save) btnUserEdit.setText(QApplication.translate("manageAccountsDlg", "Edit")) btnUserEdit.clicked.connect(self.onEditUser) btnUserDelete = self.btnManageUsers.button(QDialogButtonBox.Cancel) btnUserDelete.setText(QApplication.translate("manageAccountsDlg", "Delete")) btnUserDelete.clicked.connect(self.onDeleteUser) # Set properties for 'Roles' button box btnRoleNew = self.btnManageRoles.button(QDialogButtonBox.Ok) btnRoleNew.setText(QApplication.translate("manageAccountsDlg", "New") + "...") btnRoleNew.clicked.connect(self.onNewRole) btnRoleDelete = self.btnManageRoles.button(QDialogButtonBox.Cancel) btnRoleDelete.setText(QApplication.translate("manageAccountsDlg", "Delete")) btnRoleDelete.clicked.connect(self.onDeleteRole) btnRoleSync = self.btnManageRoles.button(QDialogButtonBox.Apply) btnRoleSync.setText(QApplication.translate("manageAccountsDlg", "Sync")) btnRoleSync.setToolTip( QApplication.translate("manageAccountsDlg", "Synchronize STDM roles with database roles")) btnRoleSync.clicked.connect(self.onSyncRoles) # Data view signals self.lstRoles.clicked.connect(self.onRoleSelected) self.lstRoles.activated.connect(self.onRoleSelected) self.lstMappingRoles.clicked.connect(self.onRoleMappingSelected) self.lstMappingRoles.activated.connect(self.onRoleMappingSelected) self.lstMappingUsers.clicked.connect(self.onUserMappingSelected) self.lstMappingUsers.activated.connect(self.onUserMappingSelected) # Disable any action by the user in the user roles mapping list view self.lstMappingUsers.setEnabled(False) def onNewUser(self): ''' Slot activated when the user requests to create a new user ''' frmNewUser = newUserDlg(self) result = frmNewUser.exec_() # Add new user to dependent models if result == QDialog.Accepted: user = frmNewUser.user # Add new user to Users view numUsers = self.usersModel.rowCount() self.usersModel.insertRows(numUsers, 1) index = self.usersModel.index(numUsers) self.usersModel.setData(index, user.UserName) # Add the user to the user mappings list userItem = self._createNewUserMapping(user.UserName) numUsers = self.UserMappingsModel.rowCount() self.UserMappingsModel.setItem(numUsers, userItem) # Sort users self.sortUsers() def loadUsers(self): ''' Loads the names of existing users ''' self.membership = Membership() users = self.membership.getAllUsers() self.usersModel = UsersRolesModel(users) self.sortUsers() self.lstUsers.setModel(self.usersModel) def loadRoles(self): ''' Loads the roles of the database cluster ''' self.roleProvider = RoleProvider() roles = self.roleProvider.GetAllRoles() roleNames = [] # Remove the postgresql role if it exists for role in roles: if role.name != 'postgres': roleNames.append(role.name) self.rolesModel = UsersRolesModel(roleNames) self.sortRoles() self.lstRoles.setModel(self.rolesModel) # Load mapping roles view as well self.lstMappingRoles.setModel(self.rolesModel) def onEditUser(self): ''' Slot activated for editing a selected user ''' selItems = self.lstUsers.selectionModel().selectedRows() if len(selItems) == 0: msg = QApplication.translate("manageAccountsDlg", "Please select a user to edit.") QMessageBox.warning(self, QApplication.translate("manageAccountsDlg", "Select User"), msg) return # Get user from the first item in the selection username = selItems[0].data() user = self.membership.getUser(username) if user != None: frmUserUpdate = newUserDlg(self, user) frmUserUpdate.exec_() def onDeleteUser(self): ''' Slot activated for deleting a selected user ''' selItems = self.lstUsers.selectionModel().selectedRows() if len(selItems) == 0: msg = QApplication.translate("manageAccountsDlg", "Please select a user to delete.") QMessageBox.warning(self, QApplication.translate("manageAccountsDlg", "Select User"), msg) return # Get user from the first item in the selection userIndex = selItems[0] username = userIndex.data() msg = QApplication.translate("manageAccountsDlg", "Are you sure you want to delete '%s'?\nOnce deleted, this user account cannot be recovered." % ( username,)) result = QMessageBox.warning(self, QApplication.translate("manageAccountsDlg", "Delete User"), msg, QMessageBox.Yes | QMessageBox.No, QMessageBox.No) if result == QMessageBox.Yes: # Delete the user self.membership.deleteUser(username) # Remove user from the list self.usersModel.removeRows(userIndex.row(), 1) # Remove corresponding item from the user mapping list view self.UserMappingsModel.removeRow(userIndex.row()) # Sort users self.sortUsers() def onSyncRoles(self): ''' Slot for synchronizing STDM roles with database cluster roles. This is very important especially on first time login by the superuser/'postgres' account ''' self.roleProvider.syncSTDMRoles() # Update view self.loadRoles() # Reset role description label self.lblRoleDescription.setText("") def sortUsers(self): ''' Sort users in ascending order ''' self.usersModel.sort(0, Qt.AscendingOrder) def sortRoles(self): ''' Sorts the roles in ascending order ''' self.rolesModel.sort(0, Qt.AscendingOrder) def onNewRole(self): ''' Slot for creating new role ''' frmNewRole = newRoleDlg(self) result = frmNewRole.exec_() if result == QDialog.Accepted: role = frmNewRole.role # Add new role to roles view numRoles = self.rolesModel.rowCount() self.rolesModel.insertRows(numRoles, 1) index = self.rolesModel.index(numRoles) self.rolesModel.setData(index, role.name) # Sort model contents self.sortRoles() def onRoleSelected(self, index): ''' Slot activated when a role item in the view is selected to load the description text. ''' roleName = index.data() role = self.roleProvider.GetRole(roleName) if role != None: self.lblRoleDescription.setText(role.description) def onDeleteRole(self): ''' Slot for deleting the selected role ''' selItems = self.lstRoles.selectionModel().selectedRows() if len(selItems) == 0: msg = QApplication.translate("manageAccountsDlg", "Please select a role to delete.") QMessageBox.warning(self, QApplication.translate("manageAccountsDlg", "Select Role"), msg) return # Get role from the first item in the selection roleIndex = selItems[0] rolename = roleIndex.data() msg = QApplication.translate("manageAccountsDlg", "Are you sure you want to delete '%s'?\nOnce deleted, this role cannot be recovered." % ( rolename,)) result = QMessageBox.warning(self, QApplication.translate("manageAccountsDlg", "Delete Role"), msg, QMessageBox.Yes | QMessageBox.No, QMessageBox.No) if result == QMessageBox.Yes: # Delete the role self.roleProvider.DeleteSTDMRole(rolename) self.roleProvider.DeleteRole(rolename) # Remove user from the list and role mappings view self.rolesModel.removeRows(roleIndex.row(), 1) self.lblRoleDescription.setText("") self.sortRoles() def loadUserMappings(self, rolename=""): ''' Loads checked/unchecked users in the user mappings list based on whether they are non/members of the specified group. If rolename is empty, then just load all users with the check state set to 'Unchecked' ''' roleUsers = [] if rolename != "": roleUsers = self.roleProvider.GetUsersInRole(rolename) sysUsers = self.usersModel._users # Initialize model self.UserMappingsModel = QStandardItemModel(len(sysUsers), 1, self) # Create standard user items (checkable and with an icon) then add them to the list view for u in range(len(sysUsers)): user = sysUsers[u] userItem = self._createNewUserMapping(user) # If the user is in the given role then set checkstate to 'checked' sysIndex = getIndex(roleUsers, user) if sysIndex != -1: userItem.setCheckState(Qt.Checked) self.UserMappingsModel.setItem(u, userItem) self.lstMappingUsers.setModel(self.UserMappingsModel) def _createNewUserMapping(self, username): ''' Adds a new user to the list of user mappings ''' # Set icon icon = QIcon() icon.addPixmap(GuiUtils.get_icon_pixmap("user.png"), QIcon.Normal, QIcon.Off) userItem = QStandardItem(icon, username) userItem.setCheckable(True) userItem.setCheckState(Qt.Unchecked) return userItem def onRoleMappingSelected(self, index): ''' Slot activated when a role item in the mapping view is selected to load the users in the specified role ''' self.lstMappingUsers.setEnabled(True) roleName = index.data() self.currentRole = roleName self.loadUserMappings(roleName) def onUserMappingSelected(self, index): ''' Slot which is called when a user item in the user mapping list has been clicked or selected to add it to the currently selected role ''' if self.currentRole != None: item = self.UserMappingsModel.itemFromIndex(index) username = item.text() self.blockSignals(True) # Add user to role if the item is selected or remove if it was checked if item.checkState() == Qt.Checked: self.roleProvider.AddUsersToRoles([username], [self.currentRole]) elif item.checkState() == Qt.Unchecked: self.roleProvider.RemoveUsersFromRoles([username], [self.currentRole]) self.blockSignals(False)
class QRiSDockWidget(QtWidgets.QDockWidget, FORM_CLASS): closingPlugin = pyqtSignal() def __init__(self, parent=None): """Constructor.""" super(QRiSDockWidget, self).__init__(parent) # Set up the user interface from Designer. # After setupUI you can access any designer object by doing # self.<objectname>, and you can use autoconnect slots - see # http://doc.qt.io/qt-5/designer-using-a-ui-file.html # #widgets-and-dialogs-with-auto-connect self.setupUi(self) self.settings = Settings() self.qris_project = None self.menu = ContextMenu() self.treeView.setContextMenuPolicy(Qt.CustomContextMenu) self.treeView.setEditTriggers(QAbstractItemView.NoEditTriggers) self.treeView.customContextMenuRequested.connect(self.open_menu) # self.treeView.doubleClicked.connect(self.default_tree_action) # self.treeView.clicked.connect(self.item_change) # self.treeView.expanded.connect(self.expand_tree_item) self.model = QStandardItemModel() self.treeView.setModel(self.model) # Take this out of init so that nodes can be added as new data is added and imported; def build_tree_view(self, qris_project, new_item=None): """Builds items in the tree view based on dictionary values that are part of the project""" self.qris_project = qris_project self.model.clear() self.tree_state = {} rootNode = self.model.invisibleRootItem() # set the project root project_node = QStandardItem(self.qris_project.project_name) project_node.setIcon(QIcon(':/plugins/qris_toolbar/icon.png')) project_node.setData('project_root', item_code['item_type']) rootNode.appendRow(project_node) self.treeView.setExpanded(project_node.index(), True) # Add project extent layers to tree extent_folder = QStandardItem("Project Extents") extent_folder.setIcon(QIcon(':/plugins/qris_toolbar/test_folder.png')) extent_folder.setData('extent_folder', item_code['item_type']) project_node.appendRow(extent_folder) for extent in self.qris_project.project_extents.values(): extent_node = QStandardItem(extent.display_name) extent_node.setIcon( QIcon(':/plugins/qris_toolbar/test_project_extent.png')) extent_node.setData('extent_node', item_code['item_type']) extent_node.setData(extent, item_code['INSTANCE']) extent_folder.appendRow(extent_node) # Add project layers node layers_folder = QStandardItem("Project Layers") layers_folder.setIcon(QIcon(':/plugins/qris_toolbar/test_folder.png')) layers_folder.setData('layers_folder', item_code['item_type']) project_node.appendRow(layers_folder) # TODO extend this for geometry types and raster layers for layer in self.qris_project.project_vector_layers.values(): layer_node = QStandardItem(layer.display_name) # TODO change icon by type layer_node.setIcon(QIcon(':/plugins/qris_toolbar/test_layers.png')) layer_node.setData('layer_node', item_code['item_type']) layer_node.setData(layer, item_code['INSTANCE']) layers_folder.appendRow(layer_node) # # Add riverscape surfaces node # # TODO go through and add layers to the tree # riverscape_surfaces_node = QStandardItem("Riverscape Surfaces") # riverscape_surfaces_node.setIcon(QIcon(':/plugins/qris_toolbar/BrowseFolder.png')) # riverscape_surfaces_node.setData('riverscape_surfaces_folder', item_code['item_type']) # riverscape_surfaces_node.setData('group', item_code['item_layer']) # project_node.appendRow(riverscape_surfaces_node) # # Add riverscape segments node # # TODO go through and add layers to the tree # riverscape_segments_node = QStandardItem("Riverscape Segments") # riverscape_segments_node.setIcon(QIcon(':/plugins/qris_toolbar/BrowseFolder.png')) # riverscape_segments_node.setData('riverscape_segments_folder', item_code['item_type']) # riverscape_segments_node.setData('group', item_code['item_layer']) # project_node.appendRow(riverscape_segments_node) # # Add detrended rasters to tree # detrended_rasters = QStandardItem("Detrended Rasters") # detrended_rasters.setIcon(QIcon(':/plugins/qris_toolbar/BrowseFolder.png')) # detrended_rasters.setData("DetrendedRastersFolder", item_code['item_type']) # detrended_rasters.setData('group', item_code['item_layer']) # project_node.appendRow(detrended_rasters) # for raster in self.qris_project.detrended_rasters.values(): # detrended_raster = QStandardItem(raster.name) # detrended_raster.setIcon(QIcon(':/plugins/qris_toolbar/qris_raster.png')) # detrended_raster.setData('DetrendedRaster', item_code['item_type']) # detrended_raster.setData(raster, item_code['INSTANCE']) # detrended_raster.setData('raster_layer', item_code['item_layer']) # detrended_rasters.appendRow(detrended_raster) # if len(raster.surfaces.values()) > 0: # item_surfaces = QStandardItem("Surfaces") # item_surfaces.setIcon(QIcon(':/plugins/qris_toolbar/BrowseFolder.png')) # item_surfaces.setData('group', item_code['item_layer']) # detrended_raster.appendRow(item_surfaces) # for surface in raster.surfaces.values(): # item_surface = QStandardItem(surface.name) # item_surface.setIcon(QIcon(':/plugins/qris_toolbar/layers/Polygon.png')) # item_surface.setData('DetrendedRasterSurface', item_code['item_type']) # item_surface.setData('surface_layer', item_code['item_layer']) # item_surface.setData(surface, item_code['INSTANCE']) # item_surfaces.appendRow(item_surface) # # Add assessments to tree # assessments_parent_node = QStandardItem("Riverscape Assessments") # assessments_parent_node.setIcon(QIcon(':/plugins/qris_toolbar/BrowseFolder.png')) # assessments_parent_node.setData('assessments_folder', item_code['item_type']) # assessments_parent_node.setData('group', item_code['item_layer']) # project_node.appendRow(assessments_parent_node) # if self.qris_project.project_assessments: # self.qris_project.assessments_path = os.path.join(self.qris_project.project_path, "Assessments.gpkg") # assessments_layer = QgsVectorLayer(self.qris_project.assessments_path + "|layername=assessments", "assessments", "ogr") # for assessment_feature in assessments_layer.getFeatures(): # assessment_node = QStandardItem(assessment_feature.attribute('assessment_date').toString('yyyy-MM-dd')) # assessment_node.setIcon(QIcon(':/plugins/qris_toolbar/BrowseFolder.png')) # assessment_node.setData('dam_assessment', item_code['item_type']) # assessment_node.setData('group', item_code['item_layer']) # assessment_node.setData(assessment_feature.attribute('fid'), item_code['feature_id']) # assessments_parent_node.appendRow(assessment_node) # assessments_parent_node.sortChildren(Qt.AscendingOrder) # Add designs to tree design_folder = QStandardItem("Low-Tech Designs") design_folder.setIcon(QIcon(':/plugins/qris_toolbar/test_folder.png')) design_folder.setData('design_folder', item_code['item_type']) project_node.appendRow(design_folder) self.treeView.setExpanded(design_folder.index(), True) design_geopackage_path = self.qris_project.project_designs.geopackage_path( self.qris_project.project_path) designs_path = design_geopackage_path + '|layername=designs' if os.path.exists(design_geopackage_path): designs_layer = QgsVectorLayer(designs_path, "designs", "ogr") for design_feature in designs_layer.getFeatures(): # If these data types stick this should be refactored into a create node function design_node = QStandardItem(design_feature.attribute('name')) design_node.setIcon( QIcon(':/plugins/qris_toolbar/test_design.png')) design_node.setData('design', item_code['item_type']) design_node.setData(design_feature.attribute('fid'), item_code['feature_id']) design_folder.appendRow(design_node) # TODO add the structure, footprint, and zoi to the tree under each design # TODO This just doesn't work very well design_folder.sortChildren(Qt.AscendingOrder) # populate structure types structure_type_folder = QStandardItem("Structure Types") structure_type_folder.setIcon( QIcon(':/plugins/qris_toolbar/test_settings.png')) structure_type_folder.setData('structure_type_folder', item_code['item_type']) design_folder.appendRow(structure_type_folder) structure_type_path = design_geopackage_path + '|layername=structure_types' structure_type_layer = QgsVectorLayer(structure_type_path, "structure_types", "ogr") for structure_type in structure_type_layer.getFeatures(): structure_type_node = QStandardItem( structure_type.attribute('name')) # TODO change the icon structure_type_node.setIcon( QIcon(':/plugins/qris_toolbar/test_structure.png')) structure_type_node.setData('structure_type', item_code['item_type']) structure_type_node.setData(structure_type.attribute('fid'), item_code['feature_id']) structure_type_folder.appendRow(structure_type_node) # populate design phases types phase_folder = QStandardItem("Implementation Phases") # TODO change icon phase_folder.setIcon(QIcon(':/plugins/qris_toolbar/test_settings.png')) phase_folder.setData('phase_folder', item_code['item_type']) design_folder.appendRow(phase_folder) phase_path = design_geopackage_path + '|layername=phases' phase_layer = QgsVectorLayer(phase_path, "phases", "ogr") for phase in phase_layer.getFeatures(): phase_node = QStandardItem(phase.attribute('name')) # TODO change the icon phase_node.setIcon(QIcon(':/plugins/qris_toolbar/test_phase.png')) phase_node.setData('phase', item_code['item_type']) phase_node.setData(phase.attribute('fid'), item_code['feature_id']) phase_folder.appendRow(phase_node) # populate zoi types zoi_type_folder = QStandardItem("ZOI Types") zoi_type_folder.setIcon( QIcon(':/plugins/qris_toolbar/test_settings.png')) zoi_type_folder.setData('zoi_type_folder', item_code['item_type']) design_folder.appendRow(zoi_type_folder) zoi_type_path = design_geopackage_path + '|layername=zoi_types' zoi_type_layer = QgsVectorLayer(zoi_type_path, "zoi_types", "ogr") for zoi_type in zoi_type_layer.getFeatures(): zoi_type_node = QStandardItem(zoi_type.attribute('name')) # TODO change the icon zoi_type_node.setIcon( QIcon(':/plugins/qris_toolbar/test_influence.png')) zoi_type_node.setData('zoi_type', item_code['item_type']) zoi_type_node.setData(zoi_type.attribute('fid'), item_code['feature_id']) zoi_type_folder.appendRow(zoi_type_node) # Add a placed for photos # photos_folder = QStandardItem("Project Photos") # photos_folder.setIcon(QIcon(':/plugins/qris_toolbar/BrowseFolder.png')) # photos_folder.setData('photos_folder', item_code['item_type']) # project_node.appendRow(photos_folder) # TODO for now we are expanding the map however need to remember expanded state or add new nodes as we add data # self.treeView.expandAll() # Check if new item is in the tree, if it is pass it to the add_to_map function # Adds a test comment if new_item is not None and new_item != '': selected_item = self._find_item_in_model(new_item) if selected_item is not None: add_to_map(self.qris_project, self.model, selected_item) def _find_item_in_model(self, name): """Looks in the tree for an item name passed from the dataChange method.""" # TODO may want to pass this is a try except block and give an informative error message selected_item = self.model.findItems(name, Qt.MatchRecursive)[0] return selected_item def get_item_expanded_state(self): """Recursively records a list of the expanded state for items in the tree""" def closeEvent(self, event): self.qris_project = None self.closingPlugin.emit() event.accept() def open_menu(self, position): """Connects signals as context menus to items in the tree""" self.menu.clear() indexes = self.treeView.selectedIndexes() if len(indexes) < 1: return # No multiselect so there is only ever one item idx = indexes[0] if not idx.isValid(): return model_item = self.model.itemFromIndex(indexes[0]) item_type = model_item.data(item_code['item_type']) if item_type == 'project_root': self.menu.addAction('EXPAND_ALL', lambda: self.expand_tree()) self.menu.addAction('COLLAPSE_ALL', lambda: self.collapse_tree()) self.menu.addAction( 'REFRESH_TREE', lambda: self.build_tree_view(self.qris_project, None)) elif item_type == "extent_folder": self.menu.addAction('ADD_PROJECT_EXTENT_LAYER', lambda: self.import_project_extent_layer()) self.menu.addAction('CREATE_BLANK_PROJECT_EXTENT_LAYER', lambda: self.create_blank_project_extent()) elif item_type == "layers_folder": self.menu.addAction('IMPORT_PROJECT_LAYER', lambda: self.import_project_layer()) elif item_type == "layer_node": self.menu.addAction( 'ADD_TO_MAP', lambda: add_to_map(self.qris_project, self.model, model_item)) elif item_type in ['extent_node', 'Project_Extent']: # self.menu.addAction('UPDATE_PROJECT_EXTENT', lambda: self.update_project_extent(model_item)) # self.menu.addAction('DELETE_PROJECT_EXTENT', lambda: self.delete_project_extent(model_item)) self.menu.addAction( 'ADD_TO_MAP', lambda: add_to_map(self.qris_project, self.model, model_item)) elif item_type == "design_folder": self.menu.addAction('ADD_DESIGN', lambda: self.add_design()) elif item_type == "design": self.menu.addAction( 'ADD_TO_MAP_OR_UPDATE_SYMBOLOGY', lambda: add_to_map(self.qris_project, self.model, model_item)) elif item_type == "structure_type_folder": self.menu.addAction('ADD_STRUCTURE_TYPE', lambda: self.add_structure_type()) elif item_type == "zoi_type_folder": self.menu.addAction('ADD_ZOI_TYPE', lambda: self.add_zoi_type()) elif item_type == "phase_folder": self.menu.addAction('ADD_PHASE', lambda: self.add_phase()) else: self.menu.clear() self.menu.exec_(self.treeView.viewport().mapToGlobal(position)) def expand_tree(self): self.treeView.expandAll() return def collapse_tree(self): self.treeView.collapseAll() return def add_assessment(self): """Initiates adding a new assessment""" self.assessment_dialog = AssessmentDlg(self.qris_project) self.assessment_dialog.dateEdit_assessment_date.setDate( QDate.currentDate()) self.assessment_dialog.dataChange.connect(self.build_tree_view) self.assessment_dialog.show() def add_design(self): """Initiates adding a new design""" self.design_dialog = DesignDlg(self.qris_project) # TODO remove this stuff about date self.design_dialog.dataChange.connect(self.build_tree_view) self.design_dialog.show() def add_structure_type(self): """Initiates adding a structure type and the structure type dialog""" # TODO First check if the path to the database exists design_geopackage_path = self.qris_project.project_designs.geopackage_path( self.qris_project.project_path) if os.path.exists(design_geopackage_path): self.structure_type_dialog = StructureTypeDlg(self.qris_project) self.structure_type_dialog.dataChange.connect(self.build_tree_view) self.structure_type_dialog.show() else: # TODO move the creation of the design data model so that this isn't necessary QMessageBox.information( self, "Structure Types", "Please create a new project design before adding structure types" ) def add_zoi_type(self): """Initiates adding a zoi type and the zoi type dialog""" # TODO First check if the path to the database exists design_geopackage_path = self.qris_project.project_designs.geopackage_path( self.qris_project.project_path) if os.path.exists(design_geopackage_path): self.zoi_type_dialog = ZoiTypeDlg(self.qris_project) self.zoi_type_dialog.dataChange.connect(self.build_tree_view) self.zoi_type_dialog.show() else: # TODO move the creation of the design data model so that this isn't necessary QMessageBox.information( self, "Structure Types", "Please create a new project design before adding a new influence type" ) def add_phase(self): """Initiates adding a new phase within the phase dialog""" # TODO First check if the path to the database exists design_geopackage_path = self.qris_project.project_designs.geopackage_path( self.qris_project.project_path) if os.path.exists(design_geopackage_path): self.phase_dialog = PhaseDlg(self.qris_project) self.phase_dialog.dataChange.connect(self.build_tree_view) self.phase_dialog.show() else: # TODO move the creation of the design data model so that this isn't necessary QMessageBox.information( self, "Structure Types", "Please create a new project design before adding phases") # This will kick off importing photos def import_photos(self): pass def add_detrended_raster(self): # last_browse_path = self.settings.getValue('lastBrowsePath') # last_dir = os.path.dirname(last_browse_path) if last_browse_path is not None else None dialog_return = QFileDialog.getOpenFileName( None, "Add Detrended Raster to QRiS project", None, self.tr("Raster Data Sources (*.tif)")) if dialog_return is not None and dialog_return[ 0] != "" and os.path.isfile(dialog_return[0]): self.addDetrendedDlg = AddDetrendedRasterDlg( None, dialog_return[0], self.qris_project) self.addDetrendedDlg.dataChange.connect(self.build_tree_view) self.addDetrendedDlg.exec() def import_project_extent_layer(self): """launches the dialog that supports import of a project extent layer polygon""" select_layer = QgsDataSourceSelectDialog() select_layer.exec() uri = select_layer.uri() if uri is not None and uri.isValid() and uri.wkbType == 3: self.project_extent_dialog = ProjectExtentDlg( uri, self.qris_project) self.project_extent_dialog.dataChange.connect(self.build_tree_view) self.project_extent_dialog.exec_() else: QMessageBox.critical(self, "Invalid Layer", "Please select a valid polygon layer") def create_blank_project_extent(self): """Adds a blank project extent that will be edited by the user""" self.project_extent_dialog = ProjectExtentDlg(None, self.qris_project) self.project_extent_dialog.dataChange.connect(self.build_tree_view) self.project_extent_dialog.exec_() def update_project_extent(self): """Renames the project extent layer""" pass # def delete_project_extent(self, selected_item): # """Deletes a project extent layer""" # display_name = selected_item.data(item_code['INSTANCE']).display_name # feature_name = selected_item.data(item_code['INSTANCE']).feature_name # geopackage_path = selected_item.data(item_code['INSTANCE']).geopackage_path(self.qris_project.project_path) # delete_ok = QMessageBox.question(self, f"Delete extent", f"Are you f*****g sure you wanna delete the extent layer: {display_name}") # if delete_ok == QMessageBox.Yes: # # remove from the map if it's there # # TODO consider doing this based on the path # for layer in QgsProject.instance().mapLayers().values(): # if layer.name() == display_name: # QgsProject.instance().removeMapLayers([layer.id()]) # iface.mapCanvas().refresh() # # TODO be sure to test whether the table exists first # gdal_delete = gdal.OpenEx(geopackage_path, gdal.OF_UPDATE, allowed_drivers=['GPKG']) # error = gdal_delete.DeleteLayer(feature_name) # gdal_delete.ExecuteSQL('VACUUM') # # TODO remove this from the Extents dictionary that will also remove from promect xml # del(self.qris_project.project_extents[feature_name]) # # refresh the project xml # self.qris_project.write_project_xml() # # refresh the tree # self.build_tree_view(self.qris_project, None) # else: # QMessageBox.information(self, "Delete extent", "No layers were deleted") def import_project_layer(self): """launches a dialog that supports import of project layers that can be clipped to a project extent""" select_layer = QgsDataSourceSelectDialog() select_layer.exec() uri = select_layer.uri() if uri is not None and uri.isValid(): # and uri.wkbType == 3: self.project_layer_dialog = ProjectLayerDlg(uri, self.qris_project) self.project_layer_dialog.dataChange.connect(self.build_tree_view) self.project_layer_dialog.exec_() else: QMessageBox.critical(self, "Invalid Layer", "Please select a valid gis layer") def explore_elevations(self, selected_item): raster = selected_item.data(item_code['INSTANCE']) self.elevation_widget = ElevationDockWidget(raster, self.qris_project) self.settings.iface.addDockWidget(Qt.LeftDockWidgetArea, self.elevation_widget) self.elevation_widget.dataChange.connect(self.build_tree_view) self.elevation_widget.show()
class QRAVEDockWidget(QDockWidget, Ui_QRAVEDockWidgetBase): closingPlugin = pyqtSignal() dataChange = pyqtSignal() showMeta = pyqtSignal() metaChange = pyqtSignal(str, str, dict, bool) def __init__(self, parent=None): """Constructor.""" super(QRAVEDockWidget, self).__init__(parent) self.setupUi(self) self.menu = ContextMenu() self.qproject = QgsProject.instance() self.qproject.cleared.connect(self.close_all) self.treeView.setContextMenuPolicy(Qt.CustomContextMenu) self.treeView.customContextMenuRequested.connect(self.open_menu) self.treeView.doubleClicked.connect(self.default_tree_action) self.treeView.clicked.connect(self.item_change) self.treeView.expanded.connect(self.expand_tree_item) self.settings = Settings() self.model = QStandardItemModel() self.loaded_projects: List(Project) = [] # Initialize our classes self.basemaps = BaseMaps() self.treeView.setModel(self.model) self.dataChange.connect(self.reload_tree) self.reload_tree() def expand_tree_item(self, idx: QModelIndex): item = self.model.itemFromIndex(idx) item_data = item.data(Qt.UserRole) if item_data and item_data.data and isinstance(item_data.data, QRaveBaseMap): item_data.data.load_layers() def _get_project(self, xml_path): try: return next(iter(self.loaded_projects)) except Exception: return None @pyqtSlot() def reload_tree(self): # re-initialize our model and reload the projects from file # Try not to do this too often if you can self.model.clear() self.loaded_projects = [] qrave_projects = self.get_project_settings() for project_path in qrave_projects: project = Project(project_path) project.load() if project is not None and project.exists is True and project.qproject is not None: self.model.appendRow(project.qproject) self.expand_children_recursive(self.model.indexFromItem(project.qproject)) self.loaded_projects.append(project) # Load the tree objects self.basemaps.load() # Now load the basemaps region = self.settings.getValue('basemapRegion') if self.settings.getValue('basemapsInclude') is True \ and region is not None and len(region) > 0 \ and region in self.basemaps.regions.keys(): self.model.appendRow(self.basemaps.regions[region]) self.expand_children_recursive(self.model.indexFromItem(self.basemaps.regions[region])) def get_project_settings(self): try: qrave_projects_raw, type_conversion_ok = self.qproject.readEntry( CONSTANTS['settingsCategory'], 'qrave_projects' ) if type_conversion_ok is False: qrave_projects = [] else: qrave_projects = json.loads(qrave_projects_raw) if qrave_projects is None or not isinstance(qrave_projects, list): qrave_projects = [] except Exception as e: self.settings.log('Error loading project settings: {}'.format(e), Qgis.Warning) qrave_projects = [] filtered = [pf for pf in qrave_projects if os.path.isfile(pf)] filtered.reverse() # We Treat this like a stack where the last project in goes on the top. # Element 0 should be the top item return filtered def set_project_settings(self, projects: List[str]): self.qproject.writeEntry(CONSTANTS['settingsCategory'], 'qrave_projects', json.dumps(projects)) @pyqtSlot() def add_project(self, xml_path: str): qrave_projects = self.get_project_settings() # If this project is not already in if xml_path not in qrave_projects: qrave_projects.append(xml_path) self.set_project_settings(qrave_projects) self.reload_tree() new_project = self._get_project(xml_path) # If this is a fresh load and the setting is set we load the default view load_default_setting = self.settings.getValue('loadDefaultView') if load_default_setting is True \ and new_project.default_view is not None \ and new_project.default_view in new_project.views: self.add_children_to_map(new_project.qproject, new_project.views[new_project.default_view]) def closeEvent(self, event): """ When the user clicks the "X" in the dockwidget titlebar """ self.hide() self.qproject.removeEntry(CONSTANTS['settingsCategory'], 'enabled') self.closingPlugin.emit() event.accept() def expand_children_recursive(self, idx: QModelIndex = None, force=False): """Expand all the children of a QTreeView node. Do it recursively TODO: Recursion might not be the best for large trees here. Args: idx (QModelIndex, optional): [description]. Defaults to None. force: ignore the "collapsed" business logic attribute """ if idx is None: idx = self.treeView.rootIndex() for idy in range(self.model.rowCount(idx)): child = self.model.index(idy, 0, idx) self.expand_children_recursive(child, force) item = self.model.itemFromIndex(idx) item_data = item.data(Qt.UserRole) if item is not None else None # NOTE: This is pretty verbose on purpose # This thing needs to have data or it defaults to being expanded if item_data is None or item_data.data is None: collapsed = False # Collapsed is an attribute set in the business logic # Never expand the QRaveBaseMap object becsause there's a network call involved elif isinstance(item_data.data, QRaveBaseMap) \ or (isinstance(item_data.data, dict) and 'collapsed' in item_data.data and item_data.data['collapsed'] == 'true'): collapsed = True else: collapsed = False if not self.treeView.isExpanded(idx) and not collapsed: self.treeView.setExpanded(idx, True) def default_tree_action(self, idx: QModelIndex): if not idx.isValid(): return item = self.model.itemFromIndex(idx) item_data: ProjectTreeData = item.data(Qt.UserRole) # This is the default action for all add-able layers including basemaps if isinstance(item_data.data, QRaveMapLayer): if item_data.data.layer_type in [QRaveMapLayer.LayerTypes.FILE, QRaveMapLayer.LayerTypes.REPORT]: self.file_system_open(item_data.data.layer_uri) else: QRaveMapLayer.add_layer_to_map(item) # Expand is the default option for wms because we might need to load the layers elif isinstance(item_data.data, QRaveBaseMap): if item_data.data.tile_type == 'wms': pass # All the XYZ layers can be added normally. else: QRaveMapLayer.add_layer_to_map(item) elif item_data.type in [QRaveTreeTypes.PROJECT_ROOT]: self.change_meta(item, item_data, True) # For folder-y types we want Expand and contract is already implemented as a default elif item_data.type in [ QRaveTreeTypes.PROJECT_FOLDER, QRaveTreeTypes.PROJECT_REPEATER_FOLDER, QRaveTreeTypes.PROJECT_VIEW_FOLDER, QRaveTreeTypes.BASEMAP_ROOT, QRaveTreeTypes.BASEMAP_SUPER_FOLDER, QRaveTreeTypes.BASEMAP_SUB_FOLDER ]: # print("Default Folder Action") pass elif item_data.type == QRaveTreeTypes.PROJECT_VIEW: print("Default View Action") self.add_view_to_map(item_data) def item_change(self, pos): """Triggered when the user selects a new item in the tree Args:pos pos ([type]): [description] """ indexes = self.treeView.selectedIndexes() # No multiselect so there is only ever one item item = self.model.itemFromIndex(indexes[0]) data_item: ProjectTreeData = item.data(Qt.UserRole) if len(indexes) < 1 or data_item.project is None or not data_item.project.exists: return # Update the metadata if we need to self.change_meta(item, data_item) def change_meta(self, item: QStandardItem, item_data: ProjectTreeData, show=False): """Update the MetaData dock widget with new information Args: item (QStandardItem): [description] data ([type]): [description] show (bool, optional): [description]. Defaults to False. """ data = item_data.data if isinstance(data, QRaveMapLayer): meta = data.meta if data.meta is not None else {} self.metaChange.emit(item.text(), MetaType.LAYER, meta, show) elif isinstance(data, QRaveBaseMap): self.metaChange.emit(item.text(), MetaType.NONE, {}, show) elif item_data.type == QRaveTreeTypes.PROJECT_ROOT: self.metaChange.emit(item.text(), MetaType.PROJECT, { 'project': item_data.project.meta, 'warehouse': item_data.project.warehouse_meta }, show) elif item_data.type in [ QRaveTreeTypes.PROJECT_FOLDER, QRaveTreeTypes.PROJECT_REPEATER_FOLDER, QRaveTreeTypes.PROJECT_VIEW_FOLDER, QRaveTreeTypes.BASEMAP_ROOT, QRaveTreeTypes.BASEMAP_SUPER_FOLDER, QRaveTreeTypes.BASEMAP_SUB_FOLDER ]: self.metaChange.emit(item.text(), MetaType.FOLDER, data or {}, show) elif isinstance(data, dict): # this is just the generic case for any kind of metadata self.metaChange.emit(item.text(), MetaType.NONE, data or {}, show) else: # Do not update the metadata if we have nothing to show self.metaChange.emit(item.text(), MetaType.NONE, {}, show) def get_warehouse_url(self, wh_meta: Dict[str, str]): if wh_meta is not None: if 'program' in wh_meta and 'id' in wh_meta: return '/'.join([CONSTANTS['warehouseUrl'], wh_meta['program'], wh_meta['id']]) elif '_rs_wh_id' in wh_meta and '_rs_wh_program' in wh_meta: return '/'.join([CONSTANTS['warehouseUrl'], wh_meta['_rs_wh_program'], wh_meta['_rs_wh_id']]) return None def project_warehouse_view(self, project: Project): """Open this project in the warehouse if the warehouse meta entries exist """ url = self.get_warehouse_url(project.warehouse_meta) if url is not None: QDesktopServices.openUrl(QUrl(url)) def layer_warehouse_view(self, data: QRaveMapLayer): """Open this project in the warehouse if the warehouse meta entries exist """ url = self.get_warehouse_url(data.meta) if url is not None: QDesktopServices.openUrl(QUrl(url)) def close_all(self): for p in range(len(self.loaded_projects)): self.close_project(self.loaded_projects[0]) def close_project(self, project: Project): """ Close the project """ try: qrave_projects_raw, type_conversion_ok = self.qproject.readEntry( CONSTANTS['settingsCategory'], 'qrave_projects' ) qrave_projects = json.loads(qrave_projects_raw) if not type_conversion_ok or qrave_projects is None: qrave_projects = [] except Exception as e: self.settings.log('Error closing project: {}'.format(e), Qgis.Warning) qrave_projects = [] # Filter out the project we want to close and reload the tree qrave_projects = [x.project_xml_path for x in self.loaded_projects if x != project] # Write the settings back to the project self.qproject.writeEntry(CONSTANTS['settingsCategory'], 'qrave_projects', json.dumps(qrave_projects)) self.loaded_projects = qrave_projects self.reload_tree() def file_system_open(self, fpath: str): """Open a file on the operating system using the default action Args: fpath (str): [description] """ qurl = QUrl.fromLocalFile(fpath) QDesktopServices.openUrl(QUrl(qurl)) def file_system_locate(self, fpath: str): """This the OS-agnostic "show in Finder" or "show in explorer" equivalent It should open the folder of the item in question Args: fpath (str): [description] """ final_path = os.path.dirname(fpath) while not os.path.isdir(final_path): final_path = os.path.dirname(final_path) qurl = QUrl.fromLocalFile(final_path) QDesktopServices.openUrl(qurl) def toggleSubtree(self, item: QStandardItem = None, expand=True): def _recurse(curritem): idx = self.model.indexFromItem(item) if expand is not self.treeView.isExpanded(idx): self.treeView.setExpanded(idx, expand) for row in range(curritem.rowCount()): _recurse(curritem.child(row)) if item is None: if expand is True: self.treeView.expandAll() else: self.treeView.collapseAll() else: _recurse(item) def add_view_to_map(self, item_data: ProjectTreeData): """Add a view and all its layers to the map Args: item (QStandardItem): [description] """ self.add_children_to_map(item_data.project.qproject, item_data.data) def add_children_to_map(self, item: QStandardItem, bl_ids: List[str] = None): """Iteratively add all children to the map Args: item (QStandardItem): [description] bl_ids (List[str], optional): List of ids to filter by so we don't load everything. this is used for loading views """ for child in self._get_children(item): # Is this something we can add to the map? project_tree_data = child.data(Qt.UserRole) if project_tree_data is not None and isinstance(project_tree_data.data, QRaveMapLayer): data = project_tree_data.data loadme = False # If this layer matches the businesslogic id filter if bl_ids is not None and len(bl_ids) > 0: if 'id' in data.bl_attr and data.bl_attr['id'] in bl_ids: loadme = True else: loadme = True if loadme is True: data.add_layer_to_map(child) def _get_children(self, root_item: QStandardItem): """Recursion is going to kill us here so do an iterative solution instead https://stackoverflow.com/questions/41949370/collect-all-items-in-qtreeview-recursively Yields: [type]: [description] """ stack = [root_item] while stack: parent = stack.pop(0) for row in range(parent.rowCount()): for column in range(parent.columnCount()): child = parent.child(row, column) yield child if child.hasChildren(): stack.append(child) def _get_parents(self, start_item: QStandardItem): stack = [] placeholder = start_item.parent() while placeholder is not None and placeholder != self.model.invisibleRootItem(): stack.append(placeholder) placeholder = start_item.parent() return stack.reverse() def open_menu(self, position): indexes = self.treeView.selectedIndexes() if len(indexes) < 1: return # No multiselect so there is only ever one item idx = indexes[0] if not idx.isValid(): return item = self.model.itemFromIndex(indexes[0]) project_tree_data = item.data(Qt.UserRole) # ProjectTreeData object data = project_tree_data.data # Could be a QRaveBaseMap, a QRaveMapLayer or just some random data # This is the layer context menu if isinstance(data, QRaveMapLayer): if data.layer_type == QRaveMapLayer.LayerTypes.WEBTILE: self.basemap_context_menu(idx, item, project_tree_data) elif data.layer_type in [QRaveMapLayer.LayerTypes.FILE, QRaveMapLayer.LayerTypes.REPORT]: self.file_layer_context_menu(idx, item, project_tree_data) else: self.map_layer_context_menu(idx, item, project_tree_data) elif isinstance(data, QRaveBaseMap): # A WMS QARaveBaseMap is just a container for layers if data.tile_type == 'wms': self.folder_dumb_context_menu(idx, item, project_tree_data) # Every other kind of basemap is an add-able layer else: self.basemap_context_menu(idx, item, project_tree_data) elif project_tree_data.type == QRaveTreeTypes.PROJECT_ROOT: self.project_context_menu(idx, item, project_tree_data) elif project_tree_data.type in [ QRaveTreeTypes.PROJECT_VIEW_FOLDER, QRaveTreeTypes.BASEMAP_ROOT, QRaveTreeTypes.BASEMAP_SUPER_FOLDER ]: self.folder_dumb_context_menu(idx, item, project_tree_data) elif project_tree_data.type in [ QRaveTreeTypes.PROJECT_FOLDER, QRaveTreeTypes.PROJECT_REPEATER_FOLDER, QRaveTreeTypes.BASEMAP_SUB_FOLDER ]: self.folder_context_menu(idx, item, project_tree_data) elif project_tree_data.type == QRaveTreeTypes.PROJECT_VIEW: self.view_context_menu(idx, item, project_tree_data) self.menu.exec_(self.treeView.viewport().mapToGlobal(position)) def map_layer_context_menu(self, idx: QModelIndex, item: QStandardItem, item_data: ProjectTreeData): self.menu.clear() self.menu.addAction('ADD_TO_MAP', lambda: QRaveMapLayer.add_layer_to_map(item), enabled=item_data.data.exists) self.menu.addAction('VIEW_LAYER_META', lambda: self.change_meta(item, item_data, True)) if bool(self.get_warehouse_url(item_data.data.meta)): self.menu.addAction('VIEW_WEB_SOURCE', lambda: self.layer_warehouse_view(item_data)) self.menu.addAction('BROWSE_FOLDER', lambda: self.file_system_locate(item_data.data.layer_uri)) def file_layer_context_menu(self, idx: QModelIndex, item: QStandardItem, item_data: ProjectTreeData): self.menu.clear() self.menu.addAction('OPEN_FILE', lambda: self.file_system_open(item_data.data.layer_uri)) self.menu.addAction('BROWSE_FOLDER', lambda: self.file_system_locate(item_data.data.layer_uri)) # Basemap context items def basemap_context_menu(self, idx: QModelIndex, item: QStandardItem, data: ProjectTreeData): self.menu.clear() self.menu.addAction('ADD_TO_MAP', lambda: QRaveMapLayer.add_layer_to_map(item)) # Folder-level context menu def folder_context_menu(self, idx: QModelIndex, item: QStandardItem, data: ProjectTreeData): self.menu.clear() self.menu.addAction('ADD_ALL_TO_MAP', lambda: self.add_children_to_map(item)) self.menu.addSeparator() self.menu.addAction('COLLAPSE_ALL', lambda: self.toggleSubtree(item, False)) self.menu.addAction('EXPAND_ALL', lambda: self.toggleSubtree(item, True)) # Some folders don't have the 'ADD_ALL_TO_MAP' functionality enabled def folder_dumb_context_menu(self, idx: QModelIndex, item: QStandardItem, data: ProjectTreeData): self.menu.clear() self.menu.addAction('COLLAPSE_ALL', lambda: self.toggleSubtree(item, False)) self.menu.addAction('EXPAND_ALL', lambda: self.toggleSubtree(item, True)) # View context items def view_context_menu(self, idx: QModelIndex, item: QStandardItem, item_data: ProjectTreeData): self.menu.clear() self.menu.addAction('ADD_ALL_TO_MAP', lambda: self.add_view_to_map(item_data)) # Project-level context menu def project_context_menu(self, idx: QModelIndex, item: QStandardItem, data: ProjectTreeData): self.menu.clear() self.menu.addAction('COLLAPSE_ALL', lambda: self.toggleSubtree(None, False)) self.menu.addAction('EXPAND_ALL', lambda: self.toggleSubtree(None, True)) self.menu.addSeparator() self.menu.addAction('BROWSE_PROJECT_FOLDER', lambda: self.file_system_locate(data.project.project_xml_path)) self.menu.addAction('VIEW_PROJECT_META', lambda: self.change_meta(item, data, True)) self.menu.addAction('WAREHOUSE_VIEW', lambda: self.project_warehouse_view(data.project), enabled=bool(self.get_warehouse_url(data.project.warehouse_meta))) self.menu.addAction('ADD_ALL_TO_MAP', lambda: self.add_children_to_map(item)) self.menu.addSeparator() self.menu.addAction('REFRESH_PROJECT_HIERARCHY', self.reload_tree) self.menu.addAction('CUSTOMIZE_PROJECT_HIERARCHY', enabled=False) self.menu.addSeparator() self.menu.addAction('CLOSE_PROJECT', lambda: self.close_project(data.project), enabled=bool(data.project))
class LookupValueSelector(WIDGET, BASE): """ A dialog that enables to select a value and code from a lookup. .. versionadded:: 1.5 """ def __init__(self, parent, lookup_entity_name, profile=None): """ Initializes LookupValueSelector. :param parent: The parent of the dialog. :type parent: QWidget :param lookup_entity_name: The lookup entity name :type lookup_entity_name: String :param profile: The current profile object :type profile: Object """ QDialog.__init__(self, parent, Qt.WindowTitleHint | Qt.WindowCloseButtonHint) self.setupUi(self) self.value_and_code = None if profile is None: self._profile = current_profile() else: self._profile = profile self.lookup_entity = self._profile.entity_by_name('{}_{}'.format( self._profile.prefix, lookup_entity_name)) self.notice = NotificationBar(self.notice_bar) self._view_model = QStandardItemModel() self.value_list_box.setModel(self._view_model) header_item = QStandardItem(lookup_entity_name) self._view_model.setHorizontalHeaderItem(0, header_item) self.populate_value_list_view() self.selected_code = None self.selected_value_code = None self.value_list_box.clicked.connect(self.validate_selected_code) def populate_value_list_view(self): """ Populates the lookup values and codes. """ self.value_and_code = self.lookup_entity.values for value, code in self.value_and_code.items(): u_value = str(value) code_value = self.lookup_entity.values[u_value] value_code = QStandardItem('{} ({})'.format( code_value.value, code.code)) value_code.setData(code.code) self._view_model.appendRow(value_code) def validate_selected_code(self): """ Validate the selected code for the presence of Code or not. """ self.notice.clear() self.selected_code_value() if self.selected_code == '': notice = QApplication.tr(self, 'The selected value has no code.') self.notice.insertWarningNotification(notice) def selected_code_value(self): """ Get the selected lookup value. """ index = self.value_list_box.currentIndex() item = self._view_model.itemFromIndex(index) self.selected_code = item.data() self.selected_value_code = item.text() def accept(self): """ Overridden QDialog accept method. """ self.selected_code_value() self.done(1) def reject(self): """ Overridden QDialog accept method. """ self.selected_code = None self.selected_value_code = None self.done(0)