def set_table_model(self, dialog, table_object, geom_type, expr_filter):
""" Sets a TableModel to @widget_name attached to
@table_name and filter @expr_filter
"""
expr = None
if expr_filter:
# Check expression
(is_valid,
expr) = self.check_expression(expr_filter) # @UnusedVariable
if not is_valid:
return expr
# Set a model with selected filter expression
table_name = f"v_edit_{geom_type}"
if self.schema_name not in table_name:
table_name = self.schema_name + "." + table_name
# Set the model
model = QSqlTableModel(db=self.controller.db)
model.setTable(table_name)
model.setEditStrategy(QSqlTableModel.OnManualSubmit)
model.select()
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
return expr
# Attach model to selected widget
if type(table_object) is str:
# self.controller.log_debug(f"set_table_model (str): {table_object}")
widget = utils_giswater.getWidget(dialog, table_object)
if not widget:
message = "Widget not found"
self.controller.log_info(message, parameter=table_object)
return expr
elif type(table_object) is QTableView:
# self.controller.log_debug(f"set_table_model: {table_object.objectName()}")
widget = table_object
else:
msg = "Table_object is not a table name or QTableView"
self.controller.log_info(msg)
return expr
if expr_filter:
widget.setModel(model)
widget.model().setFilter(expr_filter)
widget.model().select()
else:
widget.setModel(None)
return expr
def data(self, index, role):
if role == Qt.BackgroundRole:
if self.colorFunction:
if self.colorFunction(index):
return self.color_function(index)
return QSqlTableModel.data(self, index, role)
def data(self, index, role):
"""
Custom reimplementation of the method data.
It is necessary to work with value map and value relation.
index: column index
role: role used to get the data
"""
dbdata = QSqlTableModel.data(self, index, role)
column = self.headerData(index.column(), Qt.Horizontal)
if column in self.dict:
if isinstance(self.dict[column], dict):
valueMap = self.dict[column]
if str(dbdata) in list(valueMap.values()):
id = list(valueMap.values()).index(str(dbdata))
return list(valueMap.keys())[id]
elif isinstance(self.dict[column], tuple):
tupla = self.dict[column]
valueMap = self.makeValueRelationDict(tupla[0], tupla[1])
codes = str(dbdata)[1:-1].split(',')
code_names = list()
for c in codes:
if str(c) in list(valueMap.values()):
id = list(valueMap.values()).index(str(c))
code_name = list(valueMap.keys())[id]
code_names.append(code_name)
if len(code_names) > 0:
return '{%s}' % ','.join(code_names)
return dbdata
def setData(self, index, value, role=Qt.EditRole):
"""
Custom reimplementation of the method setData.
It is necessary to work with value map and value relation.
index: column index to be set
value: value to be set
role: role used
"""
column = self.headerData(index.column(), Qt.Horizontal)
newValue = value
if column in self.dict:
if isinstance(self.dict[column], dict):
valueMap = self.dict[column]
if value in valueMap:
newValue = int(valueMap[value])
else:
newValue = value
elif isinstance(self.dict[column], tuple):
tupla = self.dict[column]
valueMap = self.makeValueRelationDict(tupla[0], tupla[1])
code_names = value[1:-1].split(',')
codes = []
for code_name in code_names:
code = valueMap[code_name]
codes.append(code)
if len(codes) > 0:
newValue = '{%s}' % ','.join(map(str, codes))
return QSqlTableModel.setData(self, index, newValue, role)
def set_table_model(dialog, table_object, table_name, expr_filter):
""" Sets a TableModel to @widget_name attached to
@table_name and filter @expr_filter
"""
expr = None
if expr_filter:
# Check expression
(is_valid, expr) = check_expression_filter(expr_filter)
if not is_valid:
return expr
if global_vars.schema_name and global_vars.schema_name not in table_name:
table_name = f"{global_vars.schema_name}.{table_name}"
# Set a model with selected filter expression
model = QSqlTableModel(db=global_vars.qgis_db_credentials)
model.setTable(table_name)
model.setEditStrategy(QSqlTableModel.OnManualSubmit)
model.select()
if model.lastError().isValid():
tools_qgis.show_warning(model.lastError().text())
return expr
# Attach model to selected widget
if type(table_object) is str:
widget = get_widget(dialog, table_object)
if not widget:
message = "Widget not found"
tools_log.log_info(message, parameter=table_object)
return expr
elif type(table_object) is QTableView:
widget = table_object
else:
msg = "Table_object is not a table name or QTableView"
tools_log.log_info(msg)
return expr
if expr_filter:
widget.setModel(model)
widget.model().setFilter(expr_filter)
widget.model().select()
else:
widget.setModel(None)
return expr
def set_table_model(self, qtable, geom_type, expr_filter):
""" Sets a TableModel to @widget_name attached to @table_name and filter @expr_filter """
expr = None
if expr_filter:
# Check expression
(is_valid,
expr) = self.check_expression(expr_filter) # @UnusedVariable
if not is_valid:
return expr
# Set a model with selected filter expression
table_name = "v_edit_" + geom_type
if self.schema_name not in table_name:
table_name = self.schema_name + "." + table_name
# Set the model
model = QSqlTableModel()
model.setTable(table_name)
model.setEditStrategy(QSqlTableModel.OnManualSubmit)
model.select()
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
return expr
# Attach model to selected widget
if type(qtable) is QTableView:
widget = qtable
else:
message = "Table_object is not a table name or QTableView"
self.controller.log_info(message)
return expr
if expr_filter:
widget.setModel(model)
widget.model().setFilter(expr_filter)
widget.model().select()
else:
widget.setModel(None)
return expr
def fill_table(self, widget, table_name, filter_):
""" Set a model with selected filter.
Attach that model to selected table """
if self.schema_name not in table_name:
table_name = self.schema_name + "." + table_name
# Set model
self.model = QSqlTableModel()
self.model.setTable(table_name)
self.model.setEditStrategy(QSqlTableModel.OnManualSubmit)
if filter_:
self.model.setFilter(filter_)
self.model.setSort(0, 0)
self.model.select()
# Check for errors
if self.model.lastError().isValid():
self.controller.show_warning(self.model.lastError().text())
# Attach model to table view
widget.setModel(self.model)
def fill_table(widget, table_name, set_edit_strategy=QSqlTableModel.OnManualSubmit, expr_filter=None):
""" Set a model with selected filter.
Attach that model to selected table """
if global_vars.schema_name not in table_name:
table_name = global_vars.schema_name + "." + table_name
# Set model
model = QSqlTableModel()
model.setTable(table_name)
model.setEditStrategy(set_edit_strategy)
model.setSort(0, 0)
model.select()
# Check for errors
if model.lastError().isValid():
global_vars.controller.show_warning(model.lastError().text())
# Attach model to table view
widget.setModel(model)
if expr_filter:
widget.model().setFilter(expr_filter)
def fill_table_mincut_management(self, widget, table_name):
""" Set a model with selected filter. Attach that model to selected table """
if self.schema_name not in table_name:
table_name = self.schema_name + "." + table_name
# Set model
model = QSqlTableModel()
model.setTable(table_name)
model.setEditStrategy(QSqlTableModel.OnManualSubmit)
model.sort(0, 1)
model.select()
# Check for errors
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
# Attach model to table view
widget.setModel(model)
class ParentAction(object):
def __init__(self, iface, settings, controller, plugin_dir):
""" Class constructor """
# Initialize instance attributes
self.iface = iface
self.canvas = self.iface.mapCanvas()
self.settings = settings
self.controller = controller
self.plugin_dir = plugin_dir
self.dao = self.controller.dao
self.schema_name = self.controller.schema_name
self.project_type = None
self.plugin_version = self.get_plugin_version()
self.add_layer = AddLayer(iface, settings, controller, plugin_dir)
self.user_current_layer = None
self.rubber_point = None
self.rubber_polygon = None
def init_rubber(self):
try:
self.rubber_point = QgsRubberBand(self.canvas, 0)
self.rubber_point.setColor(Qt.yellow)
self.rubber_point.setIconSize(10)
self.rubber_polygon = QgsRubberBand(self.canvas, 2)
self.rubber_polygon.setColor(Qt.darkRed)
self.rubber_polygon.setIconSize(20)
except:
pass
def set_controller(self, controller):
""" Set controller class """
self.controller = controller
self.schema_name = self.controller.schema_name
def open_web_browser(self, dialog, widget=None):
""" Display url using the default browser """
if widget is not None:
url = utils_giswater.getWidgetText(dialog, widget)
if url == 'null':
url = 'http://www.giswater.org'
else:
url = 'http://www.giswater.org'
webbrowser.open(url)
def get_plugin_version(self):
""" Get plugin version from metadata.txt file """
# Check if metadata file exists
metadata_file = os.path.join(self.plugin_dir, 'metadata.txt')
if not os.path.exists(metadata_file):
message = "Metadata file not found"
self.controller.show_warning(message, parameter=metadata_file)
return None
metadata = configparser.ConfigParser()
metadata.read(metadata_file)
plugin_version = metadata.get('general', 'version')
if plugin_version is None:
message = "Plugin version not found"
self.controller.show_warning(message)
return plugin_version
def get_file_dialog(self, dialog, widget):
""" Get file dialog """
# Check if selected file exists. Set default value if necessary
file_path = utils_giswater.getWidgetText(dialog, widget)
if file_path is None or file_path == 'null' or not os.path.exists(str(file_path)):
folder_path = self.plugin_dir
else:
folder_path = os.path.dirname(file_path)
# Open dialog to select file
os.chdir(folder_path)
file_dialog = QFileDialog()
file_dialog.setFileMode(QFileDialog.AnyFile)
message = "Select file"
files_path, filter_ = file_dialog.getOpenFileNames(parent=None, caption=self.controller.tr(message))
file_text = ""
for file in files_path:
file_text += f"{file}\n\n"
if files_path:
utils_giswater.setWidgetText(dialog, widget, str(file_text))
return files_path
def get_folder_dialog(self, dialog, widget):
""" Get folder dialog """
# Check if selected folder exists. Set default value if necessary
folder_path = utils_giswater.getWidgetText(dialog, widget)
if folder_path is None or folder_path == 'null' or not os.path.exists(folder_path):
folder_path = os.path.expanduser("~")
# Open dialog to select folder
os.chdir(folder_path)
file_dialog = QFileDialog()
file_dialog.setFileMode(QFileDialog.Directory)
message = "Select folder"
folder_path = file_dialog.getExistingDirectory(
parent=None, caption=self.controller.tr(message), directory=folder_path)
if folder_path:
utils_giswater.setWidgetText(dialog, widget, str(folder_path))
def load_settings(self, dialog=None):
""" Load QGIS settings related with dialog position and size """
if dialog is None:
dialog = self.dlg
try:
x = self.controller.plugin_settings_value(dialog.objectName() + "_x")
y = self.controller.plugin_settings_value(dialog.objectName() + "_y")
width = self.controller.plugin_settings_value(dialog.objectName() + "_width", dialog.property('width'))
height = self.controller.plugin_settings_value(dialog.objectName() + "_height", dialog.property('height'))
v_screens = ctypes.windll.user32
screen_x = v_screens.GetSystemMetrics(78) # Width of virtual screen
screen_y = v_screens.GetSystemMetrics(79) # Height of virtual screen
monitors = v_screens.GetSystemMetrics(80) # Will return an integer of the num of display monitors present.
if (int(x) < 0 and monitors == 1) or (int(y) < 0 and monitors == 1):
dialog.resize(int(width), int(height))
else:
if int(x) > screen_x:
x = int(screen_x) - int(width)
if int(y) > screen_y:
y = int(screen_y)
dialog.setGeometry(int(x), int(y), int(width), int(height))
except:
pass
def save_settings(self, dialog=None):
""" Save QGIS settings related with dialog position and size """
if dialog is None:
dialog = self.dlg
self.controller.plugin_settings_set_value(dialog.objectName() + "_width", dialog.property('width'))
self.controller.plugin_settings_set_value(dialog.objectName() + "_height", dialog.property('height'))
self.controller.plugin_settings_set_value(dialog.objectName() + "_x", dialog.pos().x() + 8)
self.controller.plugin_settings_set_value(dialog.objectName() + "_y", dialog.pos().y() + 31)
def get_last_tab(self, dialog, selector_name):
""" Get the name of the last tab used by the user from QSettings()
:param dialog: QDialog
:param selector_name: Name of the selector (String)
:return: Name of the last tab used by the user (string)
"""
tab_name = self.controller.plugin_settings_value(f"{dialog.objectName()}_{selector_name}")
return tab_name
def save_current_tab(self, dialog, tab_widget, selector_name):
""" Save the name of current tab used by the user into QSettings()
:param dialog: QDialog
:param tab_widget: QTabWidget
:param selector_name: Name of the selector (String)
"""
index = tab_widget.currentIndex()
tab = tab_widget.widget(index)
if tab:
tab_name = tab.objectName()
dlg_name = dialog.objectName()
self.controller.plugin_settings_set_value(f"{dlg_name}_{selector_name}", tab_name)
def open_dialog(self, dlg=None, dlg_name=None, info=True, maximize_button=True, stay_on_top=True, title=None):
""" Open dialog """
# Check database connection before opening dialog
if not self.controller.check_db_connection():
return
if dlg is None or type(dlg) is bool:
dlg = self.dlg
# Set window title
if title is not None:
dlg.setWindowTitle(title)
else:
if dlg_name:
self.controller.manage_translation(dlg_name, dlg)
# Manage stay on top, maximize/minimize button and information button
# if info is True maximize flag will be ignored
# To enable maximize button you must set info to False
flags = Qt.WindowCloseButtonHint
if info:
flags |= Qt.WindowSystemMenuHint | Qt.WindowContextHelpButtonHint
else:
if maximize_button:
flags |= Qt.WindowMinMaxButtonsHint
if stay_on_top:
flags |= Qt.WindowStaysOnTopHint
dlg.setWindowFlags(flags)
# Open dialog
if issubclass(type(dlg), GwDialog):
dlg.open()
elif issubclass(type(dlg), GwMainWindow):
dlg.show()
else:
dlg.show()
def close_dialog(self, dlg=None):
""" Close dialog """
if dlg is None or type(dlg) is bool:
dlg = self.dlg
try:
self.save_settings(dlg)
dlg.close()
map_tool = self.canvas.mapTool()
# If selected map tool is from the plugin, set 'Pan' as current one
if map_tool.toolName() == '':
self.iface.actionPan().trigger()
except AttributeError:
pass
except Exception as e:
self.controller.log_info(type(e).__name__)
def multi_row_selector(self, dialog, tableleft, tableright, field_id_left, field_id_right, name='name',
hide_left=[0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
23, 24, 25, 26, 27, 28, 29, 30], hide_right=[1, 2, 3], aql=""):
"""
:param dialog:
:param tableleft: Table to consult and load on the left side
:param tableright: Table to consult and load on the right side
:param field_id_left: ID field of the left table
:param field_id_right: ID field of the right table
:param name: field name (used in add_lot.py)
:param hide_left: Columns to hide from the left table
:param hide_right: Columns to hide from the right table
:param aql: (add query left) Query added to the left side (used in basic.py def basic_exploitation_selector())
:return:
"""
# fill QTableView all_rows
tbl_all_rows = dialog.findChild(QTableView, "all_rows")
tbl_all_rows.setSelectionBehavior(QAbstractItemView.SelectRows)
schema_name = self.schema_name.replace('"', '')
query_left = f"SELECT * FROM {schema_name}.{tableleft} WHERE {name} NOT IN "
query_left += f"(SELECT {schema_name}.{tableleft}.{name} FROM {schema_name}.{tableleft}"
query_left += f" RIGHT JOIN {schema_name}.{tableright} ON {tableleft}.{field_id_left} = {tableright}.{field_id_right}"
query_left += f" WHERE cur_user = current_user)"
query_left += f" AND {field_id_left} > -1"
query_left += aql
self.fill_table_by_query(tbl_all_rows, query_left + f" ORDER BY {name};")
self.hide_colums(tbl_all_rows, hide_left)
tbl_all_rows.setColumnWidth(1, 200)
# fill QTableView selected_rows
tbl_selected_rows = dialog.findChild(QTableView, "selected_rows")
tbl_selected_rows.setSelectionBehavior(QAbstractItemView.SelectRows)
query_right = f"SELECT {tableleft}.{name}, cur_user, {tableleft}.{field_id_left}, {tableright}.{field_id_right}"
query_right += f" FROM {schema_name}.{tableleft}"
query_right += f" JOIN {schema_name}.{tableright} ON {tableleft}.{field_id_left} = {tableright}.{field_id_right}"
query_right += " WHERE cur_user = current_user"
self.fill_table_by_query(tbl_selected_rows, query_right + f" ORDER BY {name};")
self.hide_colums(tbl_selected_rows, hide_right)
tbl_selected_rows.setColumnWidth(0, 200)
# Button select
dialog.btn_select.clicked.connect(partial(self.multi_rows_selector, tbl_all_rows, tbl_selected_rows,
field_id_left, tableright, field_id_right, query_left, query_right, field_id_right))
# Button unselect
query_delete = f"DELETE FROM {schema_name}.{tableright}"
query_delete += f" WHERE current_user = cur_user AND {tableright}.{field_id_right}="
dialog.btn_unselect.clicked.connect(partial(self.unselector, tbl_all_rows,
tbl_selected_rows, query_delete, query_left, query_right, field_id_right))
# QLineEdit
dialog.txt_name.textChanged.connect(partial(self.query_like_widget_text, dialog, dialog.txt_name,
tbl_all_rows, tableleft, tableright, field_id_right, field_id_left, name, aql))
# Order control
tbl_all_rows.horizontalHeader().sectionClicked.connect(partial(self.order_by_column, tbl_all_rows, query_left))
tbl_selected_rows.horizontalHeader().sectionClicked.connect(
partial(self.order_by_column, tbl_selected_rows, query_right))
def order_by_column(self, qtable, query, idx):
"""
:param qtable: QTableView widget
:param query: Query for populate QsqlQueryModel
:param idx: The index of the clicked column
:return:
"""
oder_by = {0: "ASC", 1: "DESC"}
sort_order = qtable.horizontalHeader().sortIndicatorOrder()
col_to_sort = qtable.model().headerData(idx, Qt.Horizontal)
query += f" ORDER BY {col_to_sort} {oder_by[sort_order]}"
self.fill_table_by_query(qtable, query)
self.refresh_map_canvas()
def hide_colums(self, widget, comuns_to_hide):
for i in range(0, len(comuns_to_hide)):
widget.hideColumn(comuns_to_hide[i])
def unselector(self, qtable_left, qtable_right, query_delete, query_left, query_right, field_id_right):
selected_list = qtable_right.selectionModel().selectedRows()
if len(selected_list) == 0:
message = "Any record selected"
self.controller.show_warning(message)
return
expl_id = []
for i in range(0, len(selected_list)):
row = selected_list[i].row()
id_ = str(qtable_right.model().record(row).value(field_id_right))
expl_id.append(id_)
for i in range(0, len(expl_id)):
self.controller.execute_sql(query_delete + str(expl_id[i]))
# Refresh
oder_by = {0: "ASC", 1: "DESC"}
sort_order = qtable_left.horizontalHeader().sortIndicatorOrder()
idx = qtable_left.horizontalHeader().sortIndicatorSection()
col_to_sort = qtable_left.model().headerData(idx, Qt.Horizontal)
query_left += f" ORDER BY {col_to_sort} {oder_by[sort_order]}"
self.fill_table_by_query(qtable_left, query_left)
sort_order = qtable_right.horizontalHeader().sortIndicatorOrder()
idx = qtable_right.horizontalHeader().sortIndicatorSection()
col_to_sort = qtable_right.model().headerData(idx, Qt.Horizontal)
query_right += f" ORDER BY {col_to_sort} {oder_by[sort_order]}"
self.fill_table_by_query(qtable_right, query_right)
self.refresh_map_canvas()
def multi_rows_selector(self, qtable_left, qtable_right, id_ori,
tablename_des, id_des, query_left, query_right, field_id):
"""
:param qtable_left: QTableView origin
:param qtable_right: QTableView destini
:param id_ori: Refers to the id of the source table
:param tablename_des: table destini
:param id_des: Refers to the id of the target table, on which the query will be made
:param query_right:
:param query_left:
:param field_id:
"""
selected_list = qtable_left.selectionModel().selectedRows()
if len(selected_list) == 0:
message = "Any record selected"
self.controller.show_warning(message)
return
expl_id = []
curuser_list = []
for i in range(0, len(selected_list)):
row = selected_list[i].row()
id_ = qtable_left.model().record(row).value(id_ori)
expl_id.append(id_)
curuser = qtable_left.model().record(row).value("cur_user")
curuser_list.append(curuser)
for i in range(0, len(expl_id)):
# Check if expl_id already exists in expl_selector
sql = (f"SELECT DISTINCT({id_des}, cur_user)"
f" FROM {tablename_des}"
f" WHERE {id_des} = '{expl_id[i]}' AND cur_user = current_user")
row = self.controller.get_row(sql)
if row:
# if exist - show warning
message = "Id already selected"
self.controller.show_info_box(message, "Info", parameter=str(expl_id[i]))
else:
sql = (f"INSERT INTO {tablename_des} ({field_id}, cur_user) "
f" VALUES ({expl_id[i]}, current_user)")
self.controller.execute_sql(sql)
# Refresh
oder_by = {0: "ASC", 1: "DESC"}
sort_order = qtable_left.horizontalHeader().sortIndicatorOrder()
idx = qtable_left.horizontalHeader().sortIndicatorSection()
col_to_sort = qtable_left.model().headerData(idx, Qt.Horizontal)
query_left += f" ORDER BY {col_to_sort} {oder_by[sort_order]}"
self.fill_table_by_query(qtable_right, query_right)
sort_order = qtable_right.horizontalHeader().sortIndicatorOrder()
idx = qtable_right.horizontalHeader().sortIndicatorSection()
col_to_sort = qtable_right.model().headerData(idx, Qt.Horizontal)
query_right += f" ORDER BY {col_to_sort} {oder_by[sort_order]}"
self.fill_table_by_query(qtable_left, query_left)
self.refresh_map_canvas()
def fill_table(self, widget, table_name, set_edit_strategy=QSqlTableModel.OnManualSubmit, expr_filter=None):
""" Set a model with selected filter.
Attach that model to selected table """
if self.schema_name not in table_name:
table_name = self.schema_name + "." + table_name
# Set model
self.model = QSqlTableModel()
self.model.setTable(table_name)
self.model.setEditStrategy(set_edit_strategy)
self.model.setSort(0, 0)
self.model.select()
# Check for errors
if self.model.lastError().isValid():
self.controller.show_warning(self.model.lastError().text())
# Attach model to table view
widget.setModel(self.model)
if expr_filter:
widget.model().setFilter(expr_filter)
def fill_table_by_query(self, qtable, query):
"""
:param qtable: QTableView to show
:param query: query to set model
"""
model = QSqlQueryModel()
model.setQuery(query)
qtable.setModel(model)
qtable.show()
# Check for errors
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
def query_like_widget_text(self, dialog, text_line, qtable, tableleft, tableright, field_id_r, field_id_l, name='name', aql=''):
""" Fill the QTableView by filtering through the QLineEdit"""
schema_name = self.schema_name.replace('"', '')
query = utils_giswater.getWidgetText(dialog, text_line, return_string_null=False).lower()
sql = (f"SELECT * FROM {schema_name}.{tableleft} WHERE {name} NOT IN "
f"(SELECT {tableleft}.{name} FROM {schema_name}.{tableleft}"
f" RIGHT JOIN {schema_name}.{tableright}"
f" ON {tableleft}.{field_id_l} = {tableright}.{field_id_r}"
f" WHERE cur_user = current_user) AND LOWER({name}::text) LIKE '%{query}%'"
f" AND {field_id_l} > -1")
sql += aql
self.fill_table_by_query(qtable, sql)
def set_icon(self, widget, icon):
""" Set @icon to selected @widget """
# Get icons folder
icons_folder = os.path.join(self.plugin_dir, 'icons')
icon_path = os.path.join(icons_folder, str(icon) + ".png")
if os.path.exists(icon_path):
widget.setIcon(QIcon(icon_path))
else:
self.controller.log_info("File not found", parameter=icon_path)
def check_expression(self, expr_filter, log_info=False):
""" Check if expression filter @expr_filter is valid """
if log_info:
self.controller.log_info(expr_filter)
expr = QgsExpression(expr_filter)
if expr.hasParserError():
message = "Expression Error"
self.controller.log_warning(message, parameter=expr_filter)
return False, expr
return True, expr
def refresh_map_canvas(self, restore_cursor=False):
""" Refresh all layers present in map canvas """
self.canvas.refreshAllLayers()
for layer_refresh in self.canvas.layers():
layer_refresh.triggerRepaint()
if restore_cursor:
self.set_cursor_restore()
def set_cursor_wait(self):
""" Change cursor to 'WaitCursor' """
QApplication.setOverrideCursor(Qt.WaitCursor)
def set_cursor_restore(self):
""" Restore to previous cursors """
QApplication.restoreOverrideCursor()
def get_cursor_multiple_selection(self):
""" Set cursor for multiple selection """
path_folder = os.path.join(os.path.dirname(__file__), os.pardir)
path_cursor = os.path.join(path_folder, 'icons', '201.png')
if os.path.exists(path_cursor):
cursor = QCursor(QPixmap(path_cursor))
else:
cursor = QCursor(Qt.ArrowCursor)
return cursor
def set_table_columns(self, dialog, widget, table_name, sort_order=0, isQStandardItemModel=False):
""" Configuration of tables. Set visibility and width of columns """
widget = utils_giswater.getWidget(dialog, widget)
if not widget:
return
# Set width and alias of visible columns
columns_to_delete = []
sql = (f"SELECT columnindex, width, alias, status"
f" FROM config_form_tableview"
f" WHERE tablename = '{table_name}'"
f" ORDER BY columnindex")
rows = self.controller.get_rows(sql, log_info=False)
if not rows:
return
for row in rows:
if not row['status']:
columns_to_delete.append(row['columnindex'] - 1)
else:
width = row['width']
if width is None:
width = 100
widget.setColumnWidth(row['columnindex'] - 1, width)
widget.model().setHeaderData(row['columnindex'] - 1, Qt.Horizontal, row['alias'])
# Set order
if isQStandardItemModel:
widget.model().sort(sort_order, Qt.AscendingOrder)
else:
widget.model().setSort(sort_order, Qt.AscendingOrder)
widget.model().select()
# Delete columns
for column in columns_to_delete:
widget.hideColumn(column)
return widget
def connect_signal_selection_changed(self, option):
""" Connect signal selectionChanged """
try:
if option == "mincut_connec":
self.canvas.selectionChanged.connect(partial(self.snapping_selection_connec))
elif option == "mincut_hydro":
self.canvas.selectionChanged.connect(partial(self.snapping_selection_hydro))
except Exception:
pass
def disconnect_signal_selection_changed(self):
""" Disconnect signal selectionChanged """
try:
self.canvas.selectionChanged.disconnect()
except Exception:
pass
finally:
self.iface.actionPan().trigger()
def set_label_current_psector(self, dialog):
sql = ("SELECT t1.name FROM plan_psector AS t1 "
" INNER JOIN config_param_user AS t2 ON t1.psector_id::text = t2.value "
" WHERE t2.parameter='plan_psector_vdefault' AND cur_user = current_user")
row = self.controller.get_row(sql)
if not row:
return
utils_giswater.setWidgetText(dialog, 'lbl_vdefault_psector', row[0])
def multi_rows_delete(self, widget, table_name, column_id):
""" Delete selected elements of the table
:param QTableView widget: origin
:param table_name: table origin
:param column_id: Refers to the id of the source table
"""
# Get selected rows
selected_list = widget.selectionModel().selectedRows()
if len(selected_list) == 0:
message = "Any record selected"
self.controller.show_warning(message)
return
inf_text = ""
list_id = ""
for i in range(0, len(selected_list)):
row = selected_list[i].row()
id_ = widget.model().record(row).value(str(column_id))
inf_text += f"{id_}, "
list_id += f"'{id_}', "
inf_text = inf_text[:-2]
list_id = list_id[:-2]
message = "Are you sure you want to delete these records?"
title = "Delete records"
answer = self.controller.ask_question(message, title, inf_text)
if answer:
sql = f"DELETE FROM {table_name}"
sql += f" WHERE {column_id} IN ({list_id})"
self.controller.execute_sql(sql)
widget.model().select()
def select_features_by_expr(self, layer, expr):
""" Select features of @layer applying @expr """
if not layer:
return
if expr is None:
layer.removeSelection()
else:
it = layer.getFeatures(QgsFeatureRequest(expr))
# Build a list of feature id's from the previous result and select them
id_list = [i.id() for i in it]
if len(id_list) > 0:
layer.selectByIds(id_list)
else:
layer.removeSelection()
def hide_void_groupbox(self, dialog):
""" Hide empty groupbox """
grb_list = {}
grbox_list = dialog.findChildren(QGroupBox)
for grbox in grbox_list:
widget_list = grbox.findChildren(QWidget)
if len(widget_list) == 0:
grb_list[grbox.objectName()] = 0
grbox.setVisible(False)
return grb_list
def zoom_to_selected_features(self, layer, geom_type=None, zoom=None):
""" Zoom to selected features of the @layer with @geom_type """
if not layer:
return
self.iface.setActiveLayer(layer)
self.iface.actionZoomToSelected().trigger()
if geom_type:
# Set scale = scale_zoom
if geom_type in ('node', 'connec', 'gully'):
scale = self.scale_zoom
# Set scale = max(current_scale, scale_zoom)
elif geom_type == 'arc':
scale = self.iface.mapCanvas().scale()
if int(scale) < int(self.scale_zoom):
scale = self.scale_zoom
else:
scale = 5000
if zoom is not None:
scale = zoom
self.iface.mapCanvas().zoomScale(float(scale))
def make_list_for_completer(self, sql):
""" Prepare a list with the necessary items for the completer
:param sql: Query to be executed, where will we get the list of items (string)
:return list_items: List with the result of the query executed (List) ["item1","item2","..."]
"""
rows = self.controller.get_rows(sql)
list_items = []
if rows:
for row in rows:
list_items.append(str(row[0]))
return list_items
def set_completer_lineedit(self, qlineedit, list_items):
""" Set a completer into a QLineEdit
:param qlineedit: Object where to set the completer (QLineEdit)
:param list_items: List of items to set into the completer (List)["item1","item2","..."]
"""
completer = QCompleter()
completer.setCaseSensitivity(Qt.CaseInsensitive)
completer.setMaxVisibleItems(10)
completer.setCompletionMode(0)
completer.setFilterMode(Qt.MatchContains)
completer.popup().setStyleSheet("color: black;")
qlineedit.setCompleter(completer)
model = QStringListModel()
model.setStringList(list_items)
completer.setModel(model)
def get_max_rectangle_from_coords(self, list_coord):
""" Returns the minimum rectangle(x1, y1, x2, y2) of a series of coordinates
:type list_coord: list of coors in format ['x1 y1', 'x2 y2',....,'x99 y99']
"""
coords = list_coord.group(1)
polygon = coords.split(',')
x, y = polygon[0].split(' ')
min_x = x # start with something much higher than expected min
min_y = y
max_x = x # start with something much lower than expected max
max_y = y
for i in range(0, len(polygon)):
x, y = polygon[i].split(' ')
if x < min_x:
min_x = x
if x > max_x:
max_x = x
if y < min_y:
min_y = y
if y > max_y:
max_y = y
return max_x, max_y, min_x, min_y
def zoom_to_rectangle(self, x1, y1, x2, y2, margin=5):
rect = QgsRectangle(float(x1) - margin, float(y1) - margin, float(x2) + margin, float(y2) + margin)
self.canvas.setExtent(rect)
self.canvas.refresh()
def create_action(self, action_name, action_group, icon_num=None, text=None):
""" Creates a new action with selected parameters """
icon = None
icon_folder = self.plugin_dir + '/icons/'
icon_path = icon_folder + icon_num + '.png'
if os.path.exists(icon_path):
icon = QIcon(icon_path)
if icon is None:
action = QAction(text, action_group)
else:
action = QAction(icon, text, action_group)
action.setObjectName(action_name)
return action
def set_wait_cursor(self):
QApplication.instance().setOverrideCursor(Qt.WaitCursor)
def set_arrow_cursor(self):
QApplication.instance().setOverrideCursor(Qt.ArrowCursor)
def delete_layer_from_toc(self, layer_name):
""" Delete layer from toc if exist """
layer = None
for lyr in list(QgsProject.instance().mapLayers().values()):
if lyr.name() == layer_name:
layer = lyr
break
if layer is not None:
# Remove layer
QgsProject.instance().removeMapLayer(layer)
# Remove group if is void
root = QgsProject.instance().layerTreeRoot()
group = root.findGroup('GW Temporal Layers')
if group:
layers = group.findLayers()
if not layers:
root.removeChildNode(group)
self.delete_layer_from_toc(layer_name)
def create_body(self, form='', feature='', filter_fields='', extras=None):
""" Create and return parameters as body to functions"""
client = f'$${{"client":{{"device":4, "infoType":1, "lang":"ES"}}, '
form = f'"form":{{{form}}}, '
feature = f'"feature":{{{feature}}}, '
filter_fields = f'"filterFields":{{{filter_fields}}}'
page_info = f'"pageInfo":{{}}'
data = f'"data":{{{filter_fields}, {page_info}'
if extras is not None:
data += ', ' + extras
data += f'}}}}$$'
body = "" + client + form + feature + data
return body
def get_composers_list(self):
layour_manager = QgsProject.instance().layoutManager().layouts()
active_composers = [layout for layout in layour_manager]
return active_composers
def get_composer_index(self, name):
index = 0
composers = self.get_composers_list()
for comp_view in composers:
composer_name = comp_view.name()
if composer_name == name:
break
index += 1
return index
def set_restriction(self, dialog, widget_to_ignore, restriction):
"""
Set all widget enabled(False) or readOnly(True) except those on the tuple
:param dialog:
:param widget_to_ignore: tuple = ('widgetname1', 'widgetname2', 'widgetname3', ...)
:param restriction: roles that do not have access. tuple = ('role1', 'role1', 'role1', ...)
:return:
"""
role = self.controller.get_restriction()
if role in restriction:
widget_list = dialog.findChildren(QWidget)
for widget in widget_list:
if widget.objectName() in widget_to_ignore:
continue
# Set editable/readonly
if type(widget) in (QLineEdit, QDoubleSpinBox, QTextEdit):
widget.setReadOnly(True)
widget.setStyleSheet("QWidget {background: rgb(242, 242, 242);color: rgb(100, 100, 100)}")
elif type(widget) in (QComboBox, QCheckBox, QTableView, QPushButton):
widget.setEnabled(False)
def set_dates_from_to(self, widget_from, widget_to, table_name, field_from, field_to):
sql = (f"SELECT MIN(LEAST({field_from}, {field_to})),"
f" MAX(GREATEST({field_from}, {field_to}))"
f" FROM {table_name}")
row = self.controller.get_row(sql, log_sql=False)
current_date = QDate.currentDate()
if row:
if row[0]:
widget_from.setDate(row[0])
else:
widget_from.setDate(current_date)
if row[1]:
widget_to.setDate(row[1])
else:
widget_to.setDate(current_date)
def get_values_from_catalog(self, table_name, typevalue, order_by='id'):
sql = (f"SELECT id, idval"
f" FROM {table_name}"
f" WHERE typevalue = '{typevalue}'"
f" ORDER BY {order_by}")
rows = self.controller.get_rows(sql)
return rows
def integer_validator(self, value, widget, btn_accept):
""" Check if the value is an integer or not.
This function is called in def set_datatype_validator(self, value, widget, btn)
widget = getattr(self, f"{widget.property('datatype')}_validator")( value, widget, btn)
"""
if value is None or bool(re.search("^\d*$", value)):
widget.setStyleSheet(None)
btn_accept.setEnabled(True)
else:
widget.setStyleSheet("border: 1px solid red")
btn_accept.setEnabled(False)
def double_validator(self, value, widget, btn_accept):
""" Check if the value is double or not.
This function is called in def set_datatype_validator(self, value, widget, btn)
widget = getattr(self, f"{widget.property('datatype')}_validator")( value, widget, btn)
"""
if value is None or bool(re.search("^\d*$", value)) or bool(re.search("^\d+\.\d+$", value)):
widget.setStyleSheet(None)
btn_accept.setEnabled(True)
else:
widget.setStyleSheet("border: 1px solid red")
btn_accept.setEnabled(False)
def load_qml(self, layer, qml_path):
""" Apply QML style located in @qml_path in @layer """
if layer is None:
return False
if not os.path.exists(qml_path):
self.controller.log_warning("File not found", parameter=qml_path)
return False
if not qml_path.endswith(".qml"):
self.controller.log_warning("File extension not valid", parameter=qml_path)
return False
layer.loadNamedStyle(qml_path)
layer.triggerRepaint()
return True
def open_file_path(self, filter_="All (*.*)"):
""" Open QFileDialog """
msg = self.controller.tr("Select DXF file")
path, filter_ = QFileDialog.getOpenFileName(None, msg, "", filter_)
return path, filter_
def show_exceptions_msg(self, title, msg=""):
cat_exception = {'KeyError': 'Key on returned json from ddbb is missed.'}
self.dlg_info = DialogTextUi()
self.dlg_info.btn_accept.setVisible(False)
self.dlg_info.btn_close.clicked.connect(partial(self.close_dialog, self.dlg_info))
self.dlg_info.setWindowTitle(title)
utils_giswater.setWidgetText(self.dlg_info, self.dlg_info.txt_infolog, msg)
self.open_dialog(self.dlg_info, dlg_name='dialog_text', title=title)
def put_combobox(self, qtable, rows, field, widget_pos, combo_values):
""" Set one column of a QtableView as QComboBox with values from database.
:param qtable: QTableView to fill
:param rows: List of items to set QComboBox (["..", "..."])
:param field: Field to set QComboBox (String)
:param widget_pos: Position of the column where we want to put the QComboBox (integer)
:param combo_values: List of items to populate QComboBox (["..", "..."])
:return:
"""
for x in range(0, len(rows)):
combo = QComboBox()
row = rows[x]
# Populate QComboBox
utils_giswater.set_item_data(combo, combo_values, 1)
# Set QCombobox to wanted item
utils_giswater.set_combo_itemData(combo, str(row[field]), 1)
# Get index and put QComboBox into QTableView at index position
idx = qtable.model().index(x, widget_pos)
qtable.setIndexWidget(idx, combo)
combo.currentIndexChanged.connect(partial(self.update_status, combo, qtable, x, widget_pos))
def update_status(self, combo, qtable, pos_x, widget_pos):
""" Update values from QComboBox to QTableView
:param combo: QComboBox from which we will take the value
:param qtable: QTableView Where update values
:param pos_x: Position of the row where we want to update value (integer)
:param widget_pos:Position of the widget where we want to update value (integer)
:return:
"""
elem = combo.itemData(combo.currentIndex())
i = qtable.model().index(pos_x, widget_pos)
qtable.model().setData(i, elem[0])
i = qtable.model().index(pos_x, widget_pos + 1)
qtable.model().setData(i, elem[1])
def get_feature_by_id(self, layer, id_, field_id):
expr = "" + str(field_id) + "= '" + str(id_) + "'"
features = layer.getFeatures(QgsFeatureRequest().setFilterExpression(expr))
for feature in features:
if str(feature[field_id]) == str(id_):
return feature
return False
def document_insert(self, dialog, tablename, field, field_value):
""" Insert a document related to the current visit
:param dialog: (QDialog )
:param tablename: Name of the table to make the queries (string)
:param field: Field of the table to make the where clause (string)
:param field_value: Value to compare in the clause where (string)
"""
doc_id = dialog.doc_id.text()
if not doc_id:
message = "You need to insert doc_id"
self.controller.show_warning(message)
return
# Check if document already exist
sql = (f"SELECT doc_id"
f" FROM {tablename}"
f" WHERE doc_id = '{doc_id}' AND {field} = '{field_value}'")
row = self.controller.get_row(sql)
if row:
msg = "Document already exist"
self.controller.show_warning(msg)
return
# Insert into new table
sql = (f"INSERT INTO {tablename} (doc_id, {field})"
f" VALUES ('{doc_id}', '{field_value}')")
status = self.controller.execute_sql(sql)
if status:
message = "Document inserted successfully"
self.controller.show_info(message)
dialog.tbl_document.model().select()
def document_open(self, qtable):
""" Open selected document """
# Get selected rows
field_index = qtable.model().fieldIndex('path')
selected_list = qtable.selectionModel().selectedRows(field_index)
if not selected_list:
message = "Any record selected"
self.controller.show_info_box(message)
return
elif len(selected_list) > 1:
message = "More then one document selected. Select just one document."
self.controller.show_warning(message)
return
path = selected_list[0].data()
# Check if file exist
if os.path.exists(path):
# Open the document
if sys.platform == "win32":
os.startfile(path)
else:
opener = "open" if sys.platform == "darwin" else "xdg-open"
subprocess.call([opener, path])
else:
webbrowser.open(path)
def document_delete(self, qtable, tablename):
""" Delete record from selected rows in tbl_document """
# Get selected rows. 0 is the column of the pk 0 'id'
selected_list = qtable.selectionModel().selectedRows(0)
if len(selected_list) == 0:
message = "Any record selected"
self.controller.show_info_box(message)
return
selected_id = []
for index in selected_list:
doc_id = index.data()
selected_id.append(str(doc_id))
message = "Are you sure you want to delete these records?"
title = "Delete records"
answer = self.controller.ask_question(message, title, ','.join(selected_id))
if answer:
sql = (f"DELETE FROM {tablename}"
f" WHERE id IN ({','.join(selected_id)})")
status = self.controller.execute_sql(sql)
if not status:
message = "Error deleting data"
self.controller.show_warning(message)
return
else:
message = "Document deleted"
self.controller.show_info(message)
qtable.model().select()
def get_all_actions(self):
actions_list = self.iface.mainWindow().findChildren(QAction)
for action in actions_list:
self.controller.log_info(str(action.objectName()))
action.triggered.connect(partial(self.show_action_name, action))
def show_action_name(self, action):
self.controller.log_info(str(action.objectName()))
def get_points(self, list_coord=None):
""" Return list of QgsPoints taken from geometry
:type list_coord: list of coors in format ['x1 y1', 'x2 y2',....,'x99 y99']
"""
coords = list_coord.group(1)
polygon = coords.split(',')
points = []
for i in range(0, len(polygon)):
x, y = polygon[i].split(' ')
point = QgsPointXY(float(x), float(y))
points.append(point)
return points
def hilight_feature_by_id(self, qtable, layer_name, field_id, width, index):
""" Based on the received index and field_id, the id of the received field_id is searched within the table
and is painted in red on the canvas """
self.resetRubberbands()
layer = self.controller.get_layer_by_tablename(layer_name)
if not layer: return
row = index.row()
column_index = utils_giswater.get_col_index_by_col_name(qtable, field_id)
_id = index.sibling(row, column_index).data()
feature = self.get_feature_by_id(layer, _id, field_id)
try:
geometry = feature.geometry()
self.rubber_polygon.setToGeometry(geometry, None)
self.rubber_polygon.setColor(QColor(255, 0, 0, 100))
self.rubber_polygon.setWidth(width)
self.rubber_polygon.show()
except AttributeError:
pass
def draw_polyline(self, points, color=QColor(255, 0, 0, 100), width=5, duration_time=None):
""" Draw 'line' over canvas following list of points
:param duration_time: integer milliseconds ex: 3000 for 3 seconds
"""
if self.rubber_polygon is None:
self.init_rubber()
rb = self.rubber_polygon
polyline = QgsGeometry.fromPolylineXY(points)
rb.setToGeometry(polyline, None)
rb.setColor(color)
rb.setWidth(width)
rb.show()
# wait to simulate a flashing effect
if duration_time is not None:
QTimer.singleShot(duration_time, self.resetRubberbands)
return rb
def resetRubberbands(self):
if self.rubber_polygon is None:
self.init_rubber()
self.rubber_point.reset(0)
self.rubber_polygon.reset(2)
def restore_user_layer(self):
if self.user_current_layer:
self.iface.setActiveLayer(self.user_current_layer)
else:
layer = self.controller.get_layer_by_tablename('v_edit_node')
if layer:
self.iface.setActiveLayer(layer)
def set_style_mapzones(self):
extras = f'"mapzones":""'
body = self.create_body(extras=extras)
json_return = self.controller.get_json('gw_fct_getstylemapzones', body)
if not json_return:
return False
for mapzone in json_return['body']['data']['mapzones']:
# Loop for each mapzone returned on json
lyr = self.controller.get_layer_by_tablename(mapzone['layer'])
categories = []
status = mapzone['status']
if status == 'Disable':
pass
if lyr:
# Loop for each id returned on json
for id in mapzone['values']:
# initialize the default symbol for this geometry type
symbol = QgsSymbol.defaultSymbol(lyr.geometryType())
symbol.setOpacity(float(mapzone['opacity']))
# Setting simp
R = random.randint(0, 255)
G = random.randint(0, 255)
B = random.randint(0, 255)
if status == 'Stylesheet':
try:
R = id['stylesheet']['color'][0]
G = id['stylesheet']['color'][1]
B = id['stylesheet']['color'][2]
except TypeError:
R = random.randint(0, 255)
G = random.randint(0, 255)
B = random.randint(0, 255)
elif status == 'Random':
R = random.randint(0, 255)
G = random.randint(0, 255)
B = random.randint(0, 255)
# Setting sytle
layer_style = {'color': '{}, {}, {}'.format(int(R), int(G), int(B))}
symbol_layer = QgsSimpleFillSymbolLayer.create(layer_style)
if symbol_layer is not None:
symbol.changeSymbolLayer(0, symbol_layer)
category = QgsRendererCategory(id['id'], symbol, str(id['id']))
categories.append(category)
# apply symbol to layer renderer
if 'idname' in mapzone:
lyr.setRenderer(QgsCategorizedSymbolRenderer(mapzone['idname'], categories))
# repaint layer
lyr.triggerRepaint()
def fill_table_by_expr(self, qtable, table_name, expr):
"""
:param qtable: QTableView to show
:param expr: expression to set model
"""
if self.schema_name not in table_name:
table_name = self.schema_name + "." + table_name
model = QSqlTableModel()
model.setTable(table_name)
model.setFilter(expr)
model.setEditStrategy(QSqlTableModel.OnFieldChange)
qtable.setEditTriggers(QTableView.DoubleClicked)
model.select()
qtable.setModel(model)
qtable.show()
# Check for errors
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
def set_model_to_table(self, widget, table_name, expr_filter):
""" Set a model with selected filter.
Attach that model to selected table """
if self.schema_name not in table_name:
table_name = self.schema_name + "." + table_name
# Set model
model = QSqlTableModel();
model.setTable(table_name)
model.setEditStrategy(QSqlTableModel.OnManualSubmit)
model.setFilter(expr_filter)
model.select()
# Check for errors
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
# Attach model to table view
if widget:
widget.setModel(model)
else:
self.controller.log_info("set_model_to_table: widget not found")
def fill_main_table(self, dialog, table_name, set_edit_triggers=QTableView.NoEditTriggers, refresh_model=True):
""" Set a model with selected filter and attach it to selected table
@setEditStrategy: 0: OnFieldChange, 1: OnRowChange, 2: OnManualSubmit
"""
if self.schema_name not in table_name:
table_name = self.schema_name + "." + table_name
# Set model
model = QSqlTableModel()
model.setTable(table_name)
model.setEditStrategy(QSqlTableModel.OnFieldChange)
dialog.all_rows.setEditTriggers(set_edit_triggers)
# Check for errors
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
return
# Get all ids from Qtable selected_rows
id_all_selected_rows = self.select_all_rows(dialog.selected_rows, 'mu_id')
# Convert id_all_selected_rows to string
ids = "0, "
for x in range(0, len(id_all_selected_rows)):
ids += str(id_all_selected_rows[x]) + ", "
ids = ids[:-2] + ""
# Build expression
expr = (f" mu_name ILIKE '%{dialog.txt_search.text()}%'"
f" AND mu_id NOT IN ({ids})"
f" AND campaign_id::text = '{self.campaign_id}'"
f" OR campaign_id IS null")
self.controller.log_info(expr)
# (is_valid, expr) = self.check_expression(expr) # @UnusedVariable
# # if not is_valid:
# # return
model.setFilter(expr)
# Refresh model?
if refresh_model:
model.select()
# Attach model to table view
dialog.all_rows.setModel(model)
def setTable(self, table):
QSqlTableModel.setTable(self, table)
self.colsEditable = {
col: True
for col in range(0, self.columnCount())
} #dict of column index:editable
def fill_table(qtable,
table_name,
expr_filter=None,
edit_strategy=QSqlTableModel.OnManualSubmit,
sort_order=Qt.AscendingOrder):
""" Set a model with selected filter. Attach that model to selected table
:param qtable: tableview where set the model (QTableView)
:param table_name: database table name or view name (String)
:param expr_filter: expression to filter the model (String)
:param edit_strategy: (QSqlTableModel.OnFieldChange, QSqlTableModel.OnManualSubmit, QSqlTableModel.OnRowChange)
:param sort_order: can be 0 or 1 (Qt.AscendingOrder or Qt.AscendingOrder)
:return:
"""
if global_vars.schema_name and global_vars.schema_name not in table_name:
table_name = f"{global_vars.schema_name}.{table_name}"
# Set model
model = QSqlTableModel(db=global_vars.qgis_db_credentials)
model.setTable(table_name)
model.setEditStrategy(edit_strategy)
model.setSort(0, sort_order)
if expr_filter is not None:
model.setFilter(expr_filter)
model.select()
# Check for errors
if model.lastError().isValid():
tools_log.log_warning(f"fill_table: {model.lastError().text()}")
# Attach model to tableview
qtable.setModel(model)
class ParentAction(object):
def __init__(self, iface, settings, controller, plugin_dir):
""" Class constructor """
# Initialize instance attributes
self.iface = iface
self.canvas = self.iface.mapCanvas()
self.settings = settings
self.controller = controller
self.plugin_dir = plugin_dir
self.dao = self.controller.dao
self.schema_name = self.controller.schema_name
self.project_type = None
self.plugin_version = self.get_plugin_version()
self.add_layer = AddLayer(iface, settings, controller, plugin_dir)
def set_controller(self, controller):
""" Set controller class """
self.controller = controller
self.schema_name = self.controller.schema_name
def open_web_browser(self, dialog, widget=None):
""" Display url using the default browser """
if widget is not None:
url = utils_giswater.getWidgetText(dialog, widget)
if url == 'null':
url = 'http://www.giswater.org'
else:
url = 'http://www.giswater.org'
webbrowser.open(url)
def get_plugin_version(self):
""" Get plugin version from metadata.txt file """
# Check if metadata file exists
metadata_file = os.path.join(self.plugin_dir, 'metadata.txt')
if not os.path.exists(metadata_file):
message = "Metadata file not found"
self.controller.show_warning(message, parameter=metadata_file)
return None
metadata = configparser.ConfigParser()
metadata.read(metadata_file)
plugin_version = metadata.get('general', 'version')
if plugin_version is None:
message = "Plugin version not found"
self.controller.show_warning(message)
return plugin_version
def get_file_dialog(self, dialog, widget):
""" Get file dialog """
# Check if selected file exists. Set default value if necessary
file_path = utils_giswater.getWidgetText(dialog, widget)
if file_path is None or file_path == 'null' or not os.path.exists(
str(file_path)):
folder_path = self.plugin_dir
else:
folder_path = os.path.dirname(file_path)
# Open dialog to select file
os.chdir(folder_path)
file_dialog = QFileDialog()
file_dialog.setFileMode(QFileDialog.AnyFile)
message = "Select file"
folder_path, filter_ = file_dialog.getOpenFileName(
parent=None, caption=self.controller.tr(message))
if folder_path:
utils_giswater.setWidgetText(dialog, widget, str(folder_path))
def get_folder_dialog(self, dialog, widget):
""" Get folder dialog """
# Check if selected folder exists. Set default value if necessary
folder_path = utils_giswater.getWidgetText(dialog, widget)
if folder_path is None or folder_path == 'null' or not os.path.exists(
folder_path):
folder_path = os.path.expanduser("~")
# Open dialog to select folder
os.chdir(folder_path)
file_dialog = QFileDialog()
file_dialog.setFileMode(QFileDialog.Directory)
message = "Select folder"
folder_path = file_dialog.getExistingDirectory(
parent=None,
caption=self.controller.tr(message),
directory=folder_path)
if folder_path:
utils_giswater.setWidgetText(dialog, widget, str(folder_path))
def load_settings(self, dialog=None):
""" Load QGIS settings related with dialog position and size """
if dialog is None:
dialog = self.dlg
try:
x = self.controller.plugin_settings_value(dialog.objectName() +
"_x")
y = self.controller.plugin_settings_value(dialog.objectName() +
"_y")
width = self.controller.plugin_settings_value(
dialog.objectName() + "_width", dialog.property('width'))
height = self.controller.plugin_settings_value(
dialog.objectName() + "_height", dialog.property('height'))
if int(x) < 0 or int(y) < 0:
dialog.resize(int(width), int(height))
else:
screens = ctypes.windll.user32
screen_x = screens.GetSystemMetrics(78)
screen_y = screens.GetSystemMetrics(79)
if int(x) > screen_x:
x = int(screen_x) - int(width)
if int(y) > screen_y:
y = int(screen_y)
dialog.setGeometry(int(x), int(y), int(width), int(height))
except:
pass
def save_settings(self, dialog=None):
""" Save QGIS settings related with dialog position and size """
if dialog is None:
dialog = self.dlg
self.controller.plugin_settings_set_value(
dialog.objectName() + "_width", dialog.property('width'))
self.controller.plugin_settings_set_value(
dialog.objectName() + "_height", dialog.property('height'))
self.controller.plugin_settings_set_value(dialog.objectName() + "_x",
dialog.pos().x() + 8)
self.controller.plugin_settings_set_value(dialog.objectName() + "_y",
dialog.pos().y() + 31)
def open_dialog(self,
dlg=None,
dlg_name=None,
info=True,
maximize_button=True,
stay_on_top=True):
""" Open dialog """
if dlg is None or type(dlg) is bool:
dlg = self.dlg
# Manage i18n of the dialog
if dlg_name:
self.controller.manage_translation(dlg_name, dlg)
# Manage stay on top, maximize/minimize button and information button
# if info is True maximize flag will be ignored
# To enable maximize button you must set info to False
flags = Qt.WindowCloseButtonHint
if info:
flags |= Qt.WindowSystemMenuHint | Qt.WindowContextHelpButtonHint
else:
if maximize_button:
flags |= Qt.WindowMinMaxButtonsHint
if stay_on_top:
flags |= Qt.WindowStaysOnTopHint
dlg.setWindowFlags(flags)
# Open dialog
if issubclass(type(dlg), GwDialog):
dlg.open()
elif issubclass(type(dlg), GwMainWindow):
dlg.show()
else:
print(f"WARNING: dialog type {type(dlg)} is not handled!")
dlg.show()
def close_dialog(self, dlg=None):
""" Close dialog """
if dlg is None or type(dlg) is bool:
dlg = self.dlg
try:
self.save_settings(dlg)
dlg.close()
map_tool = self.canvas.mapTool()
# If selected map tool is from the plugin, set 'Pan' as current one
if map_tool.toolName() == '':
self.iface.actionPan().trigger()
except AttributeError:
pass
except Exception as e:
print(type(e).__name__)
def multi_row_selector(self,
dialog,
tableleft,
tableright,
field_id_left,
field_id_right,
name='name',
hide_left=[
0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
27, 28, 29, 30
],
hide_right=[1, 2, 3],
aql=""):
"""
:param dialog:
:param tableleft: Table to consult and load on the left side
:param tableright: Table to consult and load on the right side
:param field_id_left: ID field of the left table
:param field_id_right: ID field of the right table
:param name: field name (used in add_lot.py)
:param hide_left: Columns to hide from the left table
:param hide_right: Columns to hide from the right table
:param aql: (add query left) Query added to the left side (used in basic.py def basic_exploitation_selector())
:return:
"""
# fill QTableView all_rows
tbl_all_rows = dialog.findChild(QTableView, "all_rows")
tbl_all_rows.setSelectionBehavior(QAbstractItemView.SelectRows)
schema_name = self.schema_name.replace('"', '')
query_left = f"SELECT * FROM {schema_name}.{tableleft} WHERE {name} NOT IN "
query_left += f"(SELECT {tableleft}.{name} FROM {schema_name}.{tableleft}"
query_left += f" RIGHT JOIN {schema_name}.{tableright} ON {tableleft}.{field_id_left} = {tableright}.{field_id_right}"
query_left += f" WHERE cur_user = current_user)"
query_left += f" AND {field_id_left} > -1"
query_left += aql
self.fill_table_by_query(tbl_all_rows, query_left)
self.hide_colums(tbl_all_rows, hide_left)
tbl_all_rows.setColumnWidth(1, 200)
# fill QTableView selected_rows
tbl_selected_rows = dialog.findChild(QTableView, "selected_rows")
tbl_selected_rows.setSelectionBehavior(QAbstractItemView.SelectRows)
query_right = f"SELECT {tableleft}.{name}, cur_user, {tableleft}.{field_id_left}, {tableright}.{field_id_right}"
query_right += f" FROM {schema_name}.{tableleft}"
query_right += f" JOIN {schema_name}.{tableright} ON {tableleft}.{field_id_left} = {tableright}.{field_id_right}"
query_right += " WHERE cur_user = current_user"
self.fill_table_by_query(tbl_selected_rows, query_right)
self.hide_colums(tbl_selected_rows, hide_right)
tbl_selected_rows.setColumnWidth(0, 200)
# Button select
dialog.btn_select.clicked.connect(
partial(self.multi_rows_selector, tbl_all_rows, tbl_selected_rows,
field_id_left, tableright, field_id_right, query_left,
query_right, field_id_right))
# Button unselect
query_delete = f"DELETE FROM {schema_name}.{tableright}"
query_delete += f" WHERE current_user = cur_user AND {tableright}.{field_id_right}="
dialog.btn_unselect.clicked.connect(
partial(self.unselector, tbl_all_rows, tbl_selected_rows,
query_delete, query_left, query_right, field_id_right))
# QLineEdit
dialog.txt_name.textChanged.connect(
partial(self.query_like_widget_text, dialog, dialog.txt_name,
tbl_all_rows, tableleft, tableright, field_id_right,
field_id_left, name))
# Order control
tbl_all_rows.horizontalHeader().sectionClicked.connect(
partial(self.order_by_column, tbl_all_rows, query_left))
tbl_selected_rows.horizontalHeader().sectionClicked.connect(
partial(self.order_by_column, tbl_selected_rows, query_right))
def order_by_column(self, qtable, query, idx):
"""
:param qtable: QTableView widget
:param query: Query for populate QsqlQueryModel
:param idx: The index of the clicked column
:return:
"""
oder_by = {0: "ASC", 1: "DESC"}
sort_order = qtable.horizontalHeader().sortIndicatorOrder()
col_to_sort = qtable.model().headerData(idx, Qt.Horizontal)
query += f" ORDER BY {col_to_sort} {oder_by[sort_order]}"
self.fill_table_by_query(qtable, query)
self.refresh_map_canvas()
def hide_colums(self, widget, comuns_to_hide):
for i in range(0, len(comuns_to_hide)):
widget.hideColumn(comuns_to_hide[i])
def unselector(self, qtable_left, qtable_right, query_delete, query_left,
query_right, field_id_right):
selected_list = qtable_right.selectionModel().selectedRows()
if len(selected_list) == 0:
message = "Any record selected"
self.controller.show_warning(message)
return
expl_id = []
for i in range(0, len(selected_list)):
row = selected_list[i].row()
id_ = str(qtable_right.model().record(row).value(field_id_right))
expl_id.append(id_)
for i in range(0, len(expl_id)):
self.controller.execute_sql(query_delete + str(expl_id[i]))
# Refresh
oder_by = {0: "ASC", 1: "DESC"}
sort_order = qtable_left.horizontalHeader().sortIndicatorOrder()
idx = qtable_left.horizontalHeader().sortIndicatorSection()
col_to_sort = qtable_left.model().headerData(idx, Qt.Horizontal)
query_left += f" ORDER BY {col_to_sort} {oder_by[sort_order]}"
self.fill_table_by_query(qtable_left, query_left)
sort_order = qtable_right.horizontalHeader().sortIndicatorOrder()
idx = qtable_right.horizontalHeader().sortIndicatorSection()
col_to_sort = qtable_right.model().headerData(idx, Qt.Horizontal)
query_right += f" ORDER BY {col_to_sort} {oder_by[sort_order]}"
self.fill_table_by_query(qtable_right, query_right)
self.refresh_map_canvas()
def multi_rows_selector(self, qtable_left, qtable_right, id_ori,
tablename_des, id_des, query_left, query_right,
field_id):
"""
:param qtable_left: QTableView origin
:param qtable_right: QTableView destini
:param id_ori: Refers to the id of the source table
:param tablename_des: table destini
:param id_des: Refers to the id of the target table, on which the query will be made
:param query_right:
:param query_left:
:param field_id:
"""
selected_list = qtable_left.selectionModel().selectedRows()
if len(selected_list) == 0:
message = "Any record selected"
self.controller.show_warning(message)
return
expl_id = []
curuser_list = []
for i in range(0, len(selected_list)):
row = selected_list[i].row()
id_ = qtable_left.model().record(row).value(id_ori)
expl_id.append(id_)
curuser = qtable_left.model().record(row).value("cur_user")
curuser_list.append(curuser)
for i in range(0, len(expl_id)):
# Check if expl_id already exists in expl_selector
sql = (
f"SELECT DISTINCT({id_des}, cur_user)"
f" FROM {tablename_des}"
f" WHERE {id_des} = '{expl_id[i]}' AND cur_user = current_user"
)
row = self.controller.get_row(sql)
if row:
# if exist - show warning
message = "Id already selected"
self.controller.show_info_box(message,
"Info",
parameter=str(expl_id[i]))
else:
sql = (f"INSERT INTO {tablename_des} ({field_id}, cur_user) "
f" VALUES ({expl_id[i]}, current_user)")
self.controller.execute_sql(sql)
# Refresh
oder_by = {0: "ASC", 1: "DESC"}
sort_order = qtable_left.horizontalHeader().sortIndicatorOrder()
idx = qtable_left.horizontalHeader().sortIndicatorSection()
col_to_sort = qtable_left.model().headerData(idx, Qt.Horizontal)
query_left += f" ORDER BY {col_to_sort} {oder_by[sort_order]}"
self.fill_table_by_query(qtable_right, query_right)
sort_order = qtable_right.horizontalHeader().sortIndicatorOrder()
idx = qtable_right.horizontalHeader().sortIndicatorSection()
col_to_sort = qtable_right.model().headerData(idx, Qt.Horizontal)
query_right += f" ORDER BY {col_to_sort} {oder_by[sort_order]}"
self.fill_table_by_query(qtable_left, query_left)
self.refresh_map_canvas()
def fill_table_psector(self,
widget,
table_name,
set_edit_strategy=QSqlTableModel.OnManualSubmit):
""" Set a model with selected @table_name. Attach that model to selected table """
if self.schema_name not in table_name:
table_name = self.schema_name + "." + table_name
# Set model
self.model = QSqlTableModel()
self.model.setTable(table_name)
self.model.setEditStrategy(set_edit_strategy)
self.model.setSort(0, 0)
self.model.select()
# Check for errors
if self.model.lastError().isValid():
self.controller.show_warning(self.model.lastError().text())
# Attach model to table view
widget.setModel(self.model)
def fill_table(self,
widget,
table_name,
set_edit_strategy=QSqlTableModel.OnManualSubmit,
expr_filter=None):
""" Set a model with selected filter.
Attach that model to selected table """
if self.schema_name not in table_name:
table_name = self.schema_name + "." + table_name
# Set model
self.model = QSqlTableModel()
self.model.setTable(table_name)
self.model.setEditStrategy(set_edit_strategy)
self.model.setSort(0, 0)
self.model.select()
# Check for errors
if self.model.lastError().isValid():
self.controller.show_warning(self.model.lastError().text())
# Attach model to table view
widget.setModel(self.model)
if expr_filter:
widget.model().setFilter(expr_filter)
def fill_table_by_query(self, qtable, query):
"""
:param qtable: QTableView to show
:param query: query to set model
"""
model = QSqlQueryModel()
model.setQuery(query)
qtable.setModel(model)
qtable.show()
# Check for errors
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
def query_like_widget_text(self,
dialog,
text_line,
qtable,
tableleft,
tableright,
field_id_r,
field_id_l,
name='name'):
""" Fill the QTableView by filtering through the QLineEdit"""
query = utils_giswater.getWidgetText(dialog,
text_line,
return_string_null=False).lower()
sql = (
f"SELECT * FROM {tableleft} WHERE {name} NOT IN "
f"(SELECT {tableleft}.{name} FROM {tableleft}"
f" RIGHT JOIN {tableright}"
f" ON {tableleft}.{field_id_l} = {tableright}.{field_id_r}"
f" WHERE cur_user = current_user) AND LOWER({name}::text) LIKE '%{query}%'"
)
self.fill_table_by_query(qtable, sql)
def set_icon(self, widget, icon):
""" Set @icon to selected @widget """
# Get icons folder
icons_folder = os.path.join(self.plugin_dir, 'icons')
icon_path = os.path.join(icons_folder, str(icon) + ".png")
if os.path.exists(icon_path):
widget.setIcon(QIcon(icon_path))
else:
self.controller.log_info("File not found", parameter=icon_path)
def check_expression(self, expr_filter, log_info=False):
""" Check if expression filter @expr_filter is valid """
if log_info:
self.controller.log_info(expr_filter)
expr = QgsExpression(expr_filter)
if expr.hasParserError():
message = "Expression Error"
self.controller.log_warning(message, parameter=expr_filter)
return False, expr
return True, expr
def refresh_map_canvas(self, restore_cursor=False):
""" Refresh all layers present in map canvas """
self.canvas.refreshAllLayers()
for layer_refresh in self.canvas.layers():
layer_refresh.triggerRepaint()
if restore_cursor:
self.set_cursor_restore()
def set_cursor_wait(self):
""" Change cursor to 'WaitCursor' """
QApplication.setOverrideCursor(Qt.WaitCursor)
def set_cursor_restore(self):
""" Restore to previous cursors """
QApplication.restoreOverrideCursor()
def get_cursor_multiple_selection(self):
""" Set cursor for multiple selection """
path_folder = os.path.join(os.path.dirname(__file__), os.pardir)
path_cursor = os.path.join(path_folder, 'icons', '201.png')
if os.path.exists(path_cursor):
cursor = QCursor(QPixmap(path_cursor))
else:
cursor = QCursor(Qt.ArrowCursor)
return cursor
def set_table_columns(self,
dialog,
widget,
table_name,
sort_order=0,
isQStandardItemModel=False):
""" Configuration of tables. Set visibility and width of columns """
widget = utils_giswater.getWidget(dialog, widget)
if not widget:
return
# Set width and alias of visible columns
columns_to_delete = []
sql = (f"SELECT column_index, width, alias, status"
f" FROM config_client_forms"
f" WHERE table_id = '{table_name}'"
f" ORDER BY column_index")
rows = self.controller.get_rows(sql, commit=True, log_info=False)
if not rows:
return
for row in rows:
if not row['status']:
columns_to_delete.append(row['column_index'] - 1)
else:
width = row['width']
if width is None:
width = 100
widget.setColumnWidth(row['column_index'] - 1, width)
widget.model().setHeaderData(row['column_index'] - 1,
Qt.Horizontal, row['alias'])
# Set order
if isQStandardItemModel:
widget.model().sort(sort_order, Qt.AscendingOrder)
else:
widget.model().setSort(sort_order, Qt.AscendingOrder)
widget.model().select()
# Delete columns
for column in columns_to_delete:
widget.hideColumn(column)
return widget
def connect_signal_selection_changed(self, option):
""" Connect signal selectionChanged """
try:
if option == "mincut_connec":
self.canvas.selectionChanged.connect(
partial(self.snapping_selection_connec))
elif option == "mincut_hydro":
self.canvas.selectionChanged.connect(
partial(self.snapping_selection_hydro))
except Exception:
pass
def disconnect_signal_selection_changed(self):
""" Disconnect signal selectionChanged """
try:
self.canvas.selectionChanged.disconnect()
except Exception:
pass
finally:
self.iface.actionPan().trigger()
def set_label_current_psector(self, dialog):
sql = (
"SELECT t1.name FROM plan_psector AS t1 "
" INNER JOIN config_param_user AS t2 ON t1.psector_id::text = t2.value "
" WHERE t2.parameter='psector_vdefault' AND cur_user = current_user"
)
row = self.controller.get_row(sql)
if not row:
return
utils_giswater.setWidgetText(dialog, 'lbl_vdefault_psector', row[0])
def multi_rows_delete(self, widget, table_name, column_id):
""" Delete selected elements of the table
:param QTableView widget: origin
:param table_name: table origin
:param column_id: Refers to the id of the source table
"""
# Get selected rows
selected_list = widget.selectionModel().selectedRows()
if len(selected_list) == 0:
message = "Any record selected"
self.controller.show_warning(message)
return
inf_text = ""
list_id = ""
for i in range(0, len(selected_list)):
row = selected_list[i].row()
id_ = widget.model().record(row).value(str(column_id))
inf_text += f"{id_}, "
list_id += f"'{id_}', "
inf_text = inf_text[:-2]
list_id = list_id[:-2]
message = "Are you sure you want to delete these records?"
title = "Delete records"
answer = self.controller.ask_question(message, title, inf_text)
if answer:
sql = f"DELETE FROM {table_name}"
sql += f" WHERE {column_id} IN ({list_id})"
self.controller.execute_sql(sql)
widget.model().select()
def select_features_by_expr(self, layer, expr):
""" Select features of @layer applying @expr """
if not layer:
return
if expr is None:
layer.removeSelection()
else:
it = layer.getFeatures(QgsFeatureRequest(expr))
# Build a list of feature id's from the previous result and select them
id_list = [i.id() for i in it]
if len(id_list) > 0:
layer.selectByIds(id_list)
else:
layer.removeSelection()
def hide_void_groupbox(self, dialog):
""" Hide empty grupbox """
grbox_list = dialog.findChildren(QGroupBox)
for grbox in grbox_list:
widget_list = grbox.findChildren(QWidget)
if len(widget_list) == 0:
grbox.setVisible(False)
def zoom_to_selected_features(self, layer, geom_type=None, zoom=None):
""" Zoom to selected features of the @layer with @geom_type """
if not layer:
return
self.iface.setActiveLayer(layer)
self.iface.actionZoomToSelected().trigger()
if geom_type:
# Set scale = scale_zoom
if geom_type in ('node', 'connec', 'gully'):
scale = self.scale_zoom
# Set scale = max(current_scale, scale_zoom)
elif geom_type == 'arc':
scale = self.iface.mapCanvas().scale()
if int(scale) < int(self.scale_zoom):
scale = self.scale_zoom
else:
scale = 5000
if zoom is not None:
scale = zoom
self.iface.mapCanvas().zoomScale(float(scale))
def set_completer(self, tablename, widget, field_search, color='black'):
""" Set autocomplete of widget @table_object + "_id"
getting id's from selected @table_object
"""
if not widget:
return
# Set SQL
sql = (f"SELECT DISTINCT({field_search})"
f" FROM {tablename}"
f" ORDER BY {field_search}")
row = self.controller.get_rows(sql, commit=True)
for i in range(0, len(row)):
aux = row[i]
row[i] = str(aux[0])
# Set completer and model: add autocomplete in the widget
self.completer = QCompleter()
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.completer.setCompletionMode(0)
self.completer.popup().setStyleSheet("color: " + color + ";")
widget.setCompleter(self.completer)
model = QStringListModel()
model.setStringList(row)
self.completer.setModel(model)
def get_max_rectangle_from_coords(self, list_coord):
""" Returns the minimum rectangle(x1, y1, x2, y2) of a series of coordinates
:type list_coord: list of coors in format ['x1 y1', 'x2 y2',....,'x99 y99']
"""
coords = list_coord.group(1)
polygon = coords.split(',')
x, y = polygon[0].split(' ')
min_x = x # start with something much higher than expected min
min_y = y
max_x = x # start with something much lower than expected max
max_y = y
for i in range(0, len(polygon)):
x, y = polygon[i].split(' ')
if x < min_x:
min_x = x
if x > max_x:
max_x = x
if y < min_y:
min_y = y
if y > max_y:
max_y = y
return max_x, max_y, min_x, min_y
def zoom_to_rectangle(self, x1, y1, x2, y2, margin=5):
rect = QgsRectangle(
float(x1) - margin,
float(y1) - margin,
float(x2) + margin,
float(y2) + margin)
self.canvas.setExtent(rect)
self.canvas.refresh()
def create_action(self,
action_name,
action_group,
icon_num=None,
text=None):
""" Creates a new action with selected parameters """
icon = None
icon_folder = self.plugin_dir + '/icons/'
icon_path = icon_folder + icon_num + '.png'
if os.path.exists(icon_path):
icon = QIcon(icon_path)
if icon is None:
action = QAction(text, action_group)
else:
action = QAction(icon, text, action_group)
action.setObjectName(action_name)
return action
def set_wait_cursor(self):
QApplication.instance().setOverrideCursor(Qt.WaitCursor)
def set_arrow_cursor(self):
QApplication.instance().setOverrideCursor(Qt.ArrowCursor)
def delete_layer_from_toc(self, layer_name):
""" Delete layer from toc if exist """
layer = None
for lyr in list(QgsProject.instance().mapLayers().values()):
if lyr.name() == layer_name:
layer = lyr
break
if layer is not None:
QgsProject.instance().removeMapLayer(layer)
self.delete_layer_from_toc(layer_name)
def create_body(self, form='', feature='', filter_fields='', extras=None):
""" Create and return parameters as body to functions"""
client = '"client":{"device":9, "infoType":100, "lang":"ES"}, '
form = f'"form":{{{form}}}, '
feature = f'"feature":{{{feature}}}, '
filter_fields = f'"filterFields":{{{filter_fields}}}'
page_info = '"pageInfo":{}'
data = f'"data":{{{filter_fields}, {page_info}'
if extras is not None:
data += ', ' + extras
data += '}'
body = "" + client + form + feature + data
return body
def set_layers_visible(self, layers):
for layer in layers:
lyr = self.controller.get_layer_by_tablename(layer)
if lyr:
self.controller.set_layer_visible(lyr)
def add_temp_layer(self,
dialog,
data,
function_name,
force_tab=True,
reset_text=True,
tab_idx=1,
del_old_layers=True):
if del_old_layers:
self.delete_layer_from_toc(function_name)
srid = self.controller.plugin_settings_value('srid')
for k, v in list(data.items()):
if str(k) == 'setVisibleLayers':
self.set_layers_visible(v)
elif str(k) == "info":
self.populate_info_text(dialog, data, force_tab, reset_text,
tab_idx)
else:
counter = len(data[k]['values'])
if counter > 0:
counter = len(data[k]['values'])
geometry_type = data[k]['geometryType']
v_layer = QgsVectorLayer(
f"{geometry_type}?crs=epsg:{srid}", function_name,
'memory')
self.populate_vlayer(v_layer, data, k, counter)
if 'qmlPath' in data[k]:
qml_path = data[k]['qmlPath']
self.load_qml(v_layer, qml_path)
def populate_info_text(self,
dialog,
data,
force_tab=True,
reset_text=True,
tab_idx=1):
change_tab = False
text = utils_giswater.getWidgetText(dialog,
dialog.txt_infolog,
return_string_null=False)
if reset_text:
text = ""
for item in data['info']['values']:
if 'message' in item:
if item['message'] is not None:
text += str(item['message']) + "\n"
if force_tab:
change_tab = True
else:
text += "\n"
utils_giswater.setWidgetText(dialog, 'txt_infolog', text + "\n")
qtabwidget = dialog.findChild(QTabWidget, 'mainTab')
if change_tab and qtabwidget is not None:
qtabwidget.setCurrentIndex(tab_idx)
return change_tab
def populate_vlayer(self, virtual_layer, data, layer_type, counter):
prov = virtual_layer.dataProvider()
# Enter editing mode
virtual_layer.startEditing()
if counter > 0:
for key, value in list(data[layer_type]['values'][0].items()):
# add columns
if str(key) != 'the_geom':
prov.addAttributes([QgsField(str(key), QVariant.String)])
# Add features
for item in data[layer_type]['values']:
attributes = []
fet = QgsFeature()
for k, v in list(item.items()):
if str(k) != 'the_geom':
attributes.append(v)
if str(k) in 'the_geom':
sql = f"SELECT St_AsText('{v}')"
row = self.controller.get_row(sql, log_sql=False)
geometry = QgsGeometry.fromWkt(str(row[0]))
fet.setGeometry(geometry)
fet.setAttributes(attributes)
prov.addFeatures([fet])
# Commit changes
virtual_layer.commitChanges()
QgsProject.instance().addMapLayer(virtual_layer, False)
root = QgsProject.instance().layerTreeRoot()
my_group = root.findGroup('GW Functions results')
if my_group is None:
my_group = root.insertGroup(0, 'GW Functions results')
my_group.insertLayer(0, virtual_layer)
def get_composers_list(self):
layour_manager = QgsProject.instance().layoutManager().layouts()
active_composers = [layout for layout in layour_manager]
return active_composers
def get_composer_index(self, name):
index = 0
composers = self.get_composers_list()
for comp_view in composers:
composer_name = comp_view.name()
if composer_name == name:
break
index += 1
return index
def get_all_actions(self):
self.controller.log_info(str("TEST"))
actions_list = self.iface.mainWindow().findChildren(QAction)
for action in actions_list:
self.controller.log_info(str(action.objectName()))
action.triggered.connect(partial(self.show_action_name, action))
def show_action_name(self, action):
self.controller.log_info(str(action.objectName()))
def set_restriction(self, dialog, widget_to_ignore, restriction):
"""
Set all widget enabled(False) or readOnly(True) except those on the tuple
:param dialog:
:param widget_to_ignore: tuple = ('widgetname1', 'widgetname2', 'widgetname3', ...)
:param restriction: roles that do not have access. tuple = ('role1', 'role1', 'role1', ...)
:return:
"""
role = self.controller.get_restriction()
if role in restriction:
widget_list = dialog.findChildren(QWidget)
for widget in widget_list:
if widget.objectName() in widget_to_ignore:
continue
# Set editable/readonly
if type(widget) in (QLineEdit, QDoubleSpinBox, QTextEdit):
widget.setReadOnly(True)
widget.setStyleSheet(
"QWidget {background: rgb(242, 242, 242);color: rgb(100, 100, 100)}"
)
elif type(widget) in (QComboBox, QCheckBox, QTableView,
QPushButton):
widget.setEnabled(False)
def set_dates_from_to(self, widget_from, widget_to, table_name, field_from,
field_to):
sql = (f"SELECT MIN(LEAST({field_from}, {field_to})),"
f" MAX(GREATEST({field_from}, {field_to}))"
f" FROM {table_name}")
row = self.controller.get_row(sql, log_sql=False)
current_date = QDate.currentDate()
if row:
if row[0]:
widget_from.setDate(row[0])
else:
widget_from.setDate(current_date)
if row[1]:
widget_to.setDate(row[1])
else:
widget_to.setDate(current_date)
def get_values_from_catalog(self, table_name, typevalue, order_by='id'):
sql = (f"SELECT id, idval"
f" FROM {table_name}"
f" WHERE typevalue = '{typevalue}'"
f" ORDER BY {order_by}")
rows = self.controller.get_rows(sql, commit=True)
return rows
def integer_validator(self, value, widget, btn_accept):
""" Check if the value is an integer or not.
This function is called in def set_datatype_validator(self, value, widget, btn)
widget = getattr(self, f"{widget.property('datatype')}_validator")( value, widget, btn)
"""
if value is None or bool(re.search("^\d*$", value)):
widget.setStyleSheet(
"QLineEdit{background:rgb(255, 255, 255); color:rgb(0, 0, 0)}")
btn_accept.setEnabled(True)
else:
widget.setStyleSheet("border: 1px solid red")
btn_accept.setEnabled(False)
def double_validator(self, value, widget, btn_accept):
""" Check if the value is double or not.
This function is called in def set_datatype_validator(self, value, widget, btn)
widget = getattr(self, f"{widget.property('datatype')}_validator")( value, widget, btn)
"""
if value is None or bool(re.search("^\d*$", value)) or bool(
re.search("^\d+\.\d+$", value)):
widget.setStyleSheet(
"QLineEdit{background:rgb(255, 255, 255); color:rgb(0, 0, 0)}")
btn_accept.setEnabled(True)
else:
widget.setStyleSheet("border: 1px solid red")
btn_accept.setEnabled(False)
def load_qml(self, layer, qml_path):
""" Apply QML style located in @qml_path in @layer """
if layer is None:
return False
if not os.path.exists(qml_path):
self.controller.log_warning("File not found", parameter=qml_path)
return False
if not qml_path.endswith(".qml"):
self.controller.log_warning("File extension not valid",
parameter=qml_path)
return False
layer.loadNamedStyle(qml_path)
layer.triggerRepaint()
return True
def open_file_path(self, filter_="All (*.*)"):
""" Open QFileDialog """
msg = self.controller.tr("Select DXF file")
path, filter_ = QFileDialog.getOpenFileName(None, msg, "", filter_)
return path, filter_
def show_exceptions_msg(self, title, msg=""):
cat_exception = {
'KeyError': 'Key on returned json from ddbb is missed.'
}
self.dlg_info = BasicInfo()
self.dlg_info.btn_accept.setVisible(False)
self.dlg_info.btn_close.clicked.connect(
partial(self.close_dialog, self.dlg_info))
self.dlg_info.setWindowTitle(title)
utils_giswater.setWidgetText(self.dlg_info, self.dlg_info.txt_info,
msg)
self.open_dialog(self.dlg_info)
def fill_table_planned_month(self, qtable, txt_filter, tableright, expression=None, set_edit_triggers=QTableView.NoEditTriggers):
""" Set a model with selected filter and attach it to selected table
@setEditStrategy: 0: OnFieldChange, 1: OnRowChange, 2: OnManualSubmit
"""
if self.schema_name not in tableright:
tableright = f"{self.schema_name}.{tableright}"
# Set model
model = QSqlTableModel()
model.setTable(tableright)
model.setEditStrategy(QSqlTableModel.OnManualSubmit)
model.setSort(2, 0)
model.select()
qtable.setEditTriggers(set_edit_triggers)
# Check for errors
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
# Create expresion
expr = (f" mu_name ILIKE '%{txt_filter.text()}%' "
f" AND campaign_id = '{self.planned_camp_id}' ")
if expression is not None:
expr += expression
qtable.setModel(model)
qtable.model().setFilter(expr)
def fill_table(self, dialog, table_view, set_edit_triggers=QTableView.NoEditTriggers, update=False):
""" Set a model with selected filter and attach it to selected table
@setEditStrategy: 0: OnFieldChange, 1: OnRowChange, 2: OnManualSubmit
"""
if self.schema_name not in table_view:
table_view = self.schema_name + "." + table_view
# Set model
model = QSqlTableModel()
model.setTable(table_view)
model.setEditStrategy(QSqlTableModel.OnManualSubmit)
model.setSort(2, 0)
model.select()
dialog.selected_rows.setEditTriggers(set_edit_triggers)
# Check for errors
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
# Create expresion
expr = f" mu_name ILIKE '%{dialog.txt_selected_filter.text()}%'"
if self.selected_camp is not None:
expr += f" AND campaign_id = '{self.campaign_id}'"
if update:
expr += f" OR campaign_id = '{self.selected_camp}'"
# Attach model to table or view
dialog.selected_rows.setModel(model)
dialog.selected_rows.model().setFilter(expr)
# Set year to plan to all rows in list
for x in range(0, model.rowCount()):
i = int(dialog.selected_rows.model().fieldIndex('campaign_id'))
index = dialog.selected_rows.model().index(x, i)
model.setData(index, self.campaign_id)
self.calculate_total_price(dialog, self.campaign_id)
def workcat_fill_table(self,
widget,
table_name,
hidde=False,
set_edit_triggers=QTableView.NoEditTriggers,
expr=None):
""" Fill table @widget filtering query by @workcat_id
Set a model with selected filter.
Attach that model to selected table
@setEditStrategy:
0: OnFieldChange
1: OnRowChange
2: OnManualSubmit
"""
if self.schema_name not in table_name:
table_name = self.schema_name + "." + table_name
# Set model
model = QSqlTableModel()
model.setTable(table_name)
model.setEditStrategy(QSqlTableModel.OnFieldChange)
model.setSort(0, 0)
model.select()
widget.setEditTriggers(set_edit_triggers)
# Check for errors
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
# Attach model to table view
if expr:
widget.setModel(model)
widget.model().setFilter(expr)
else:
widget.setModel(model)
if hidde:
self.refresh_table(widget)
class GwFeatureEnd(ParentManage):
def __init__(self, iface, settings, controller, plugin_dir):
""" Class to control 'Workcat end' of toolbar 'edit' """
ParentManage.__init__(self, iface, settings, controller, plugin_dir)
def manage_workcat_end(self):
self.remove_selection(True)
# Create the dialog and signals
self.dlg_work_end = FeatureEndUi()
self.load_settings(self.dlg_work_end)
self.set_edit_arc_downgrade_force('True')
# Capture the current layer to return it at the end of the operation
self.cur_active_layer = self.iface.activeLayer()
self.set_selectionbehavior(self.dlg_work_end)
# Get layers of every geom_type
self.reset_lists()
self.reset_layers()
self.layers['arc'] = self.controller.get_group_layers('arc')
self.layers['node'] = self.controller.get_group_layers('node')
self.layers['connec'] = self.controller.get_group_layers('connec')
self.layers['element'] = [
self.controller.get_layer_by_tablename('v_edit_element')
]
# Remove 'gully' for 'WS'
self.project_type = self.controller.get_project_type()
if self.project_type == 'ws':
self.dlg_work_end.tab_feature.removeTab(4)
else:
self.layers['gully'] = self.controller.get_group_layers('gully')
# Set icons
self.set_icon(self.dlg_work_end.btn_insert, "111")
self.set_icon(self.dlg_work_end.btn_delete, "112")
self.set_icon(self.dlg_work_end.btn_snapping, "137")
self.set_icon(self.dlg_work_end.btn_new_workcat, "193")
# Adding auto-completion to a QLineEdit
self.table_object = "cat_work"
self.set_completer_object(self.dlg_work_end, self.table_object)
# Set signals
self.dlg_work_end.btn_accept.clicked.connect(
partial(self.manage_workcat_end_accept))
self.dlg_work_end.btn_cancel.clicked.connect(
partial(self.manage_close,
self.dlg_work_end,
self.table_object,
self.cur_active_layer,
force_downgrade=True))
self.dlg_work_end.rejected.connect(
partial(self.manage_close,
self.dlg_work_end,
self.table_object,
self.cur_active_layer,
force_downgrade=True,
show_warning=True))
self.dlg_work_end.workcat_id_end.editTextChanged.connect(
partial(self.fill_workids))
self.dlg_work_end.btn_new_workcat.clicked.connect(
partial(self.new_workcat))
self.dlg_work_end.btn_insert.clicked.connect(
partial(self.insert_feature, self.dlg_work_end, self.table_object))
self.dlg_work_end.btn_delete.clicked.connect(
partial(self.delete_records, self.dlg_work_end, self.table_object))
self.dlg_work_end.btn_snapping.clicked.connect(
partial(self.selection_init, self.dlg_work_end, self.table_object))
self.dlg_work_end.workcat_id_end.activated.connect(
partial(self.fill_workids))
self.dlg_work_end.tab_feature.currentChanged.connect(
partial(self.tab_feature_changed,
self.dlg_work_end,
self.table_object,
excluded_layers=["v_edit_element"]))
# Set values
self.fill_fields()
# Adding auto-completion to a QLineEdit for default feature
geom_type = "arc"
viewname = "v_edit_" + geom_type
self.set_completer_feature_id(self.dlg_work_end.feature_id, geom_type,
viewname)
# Set default tab 'arc'
self.dlg_work_end.tab_feature.setCurrentIndex(0)
self.geom_type = "arc"
self.tab_feature_changed(self.dlg_work_end,
self.table_object,
excluded_layers=["v_edit_element"])
# Open dialog
self.open_dialog(self.dlg_work_end,
dlg_name='feature_end',
maximize_button=False)
def set_edit_arc_downgrade_force(self, value):
# Update (or insert) on config_param_user the value of edit_arc_downgrade_force to true
row = self.controller.get_config('edit_arc_downgrade_force')
if row:
sql = (
f"UPDATE config_param_user "
f"SET value = '{value}' "
f"WHERE parameter = 'edit_arc_downgrade_force' AND cur_user=current_user"
)
self.controller.execute_sql(sql, log_sql=True)
else:
sql = (
f"INSERT INTO config_param_user (parameter, value, cur_user) "
f"VALUES ('edit_arc_downgrade_force', '{value}', current_user)"
)
self.controller.execute_sql(sql)
def fill_fields(self):
""" Fill dates and combos cat_work/state type end """
sql = 'SELECT id as id, name as idval FROM value_state_type WHERE id IS NOT NULL AND state = 0'
rows = self.controller.get_rows(sql)
qt_tools.set_item_data(self.dlg_work_end.cmb_statetype_end, rows, 1)
row = self.controller.get_config('statetype_end_vdefault')
if row:
qt_tools.set_combo_itemData(self.dlg_work_end.cmb_statetype_end,
row[0], 0)
row = self.controller.get_config('edit_enddate_vdefault')
if row:
enddate = self.manage_dates(row[0]).date()
self.dlg_work_end.enddate.setDate(enddate)
else:
enddate = QDate.currentDate()
qt_tools.setCalendarDate(self.dlg_work_end, "enddate", enddate)
sql = "SELECT id FROM cat_work"
rows = self.controller.get_rows(sql)
qt_tools.fillComboBox(self.dlg_work_end,
self.dlg_work_end.workcat_id_end,
rows,
allow_nulls=False)
qt_tools.set_autocompleter(self.dlg_work_end.workcat_id_end)
row = self.controller.get_config('edit_workcat_end_vdefault')
if row:
qt_tools.setWidgetText(self.dlg_work_end,
self.dlg_work_end.workcat_id_end, row[0])
def manage_dates(self, date_value):
""" Manage dates """
date_result = None
try:
date_result = str(date_value)
date_result = date_result.replace("-", "/")
date_result = datetime.strptime(date_result, '%Y/%m/%d')
except Exception as e:
self.controller.log_warning(str(e))
finally:
return date_result
def fill_workids(self):
""" Auto fill descriptions and workid's """
workcat_id = qt_tools.getWidgetText(self.dlg_work_end,
self.dlg_work_end.workcat_id_end)
if not workcat_id:
return
sql = (f"SELECT descript, builtdate "
f"FROM cat_work "
f"WHERE id = '{workcat_id}'")
row = self.controller.get_row(sql)
if row:
qt_tools.setText(self.dlg_work_end, self.dlg_work_end.descript,
row['descript'])
qt_tools.setCalendarDate(self.dlg_work_end,
self.dlg_work_end.builtdate,
row['builtdate'], False)
else:
qt_tools.setText(self.dlg_work_end, self.dlg_work_end.descript, '')
qt_tools.setCalendarDate(self.dlg_work_end,
self.dlg_work_end.builtdate, None, False)
def get_list_selected_id(self, qtable):
selected_list = qtable.model()
self.selected_list = []
ids_list = ""
if selected_list is None:
self.manage_close(self.dlg_work_end,
self.table_object,
self.cur_active_layer,
force_downgrade=False)
return
for x in range(0, selected_list.rowCount()):
index = selected_list.index(x, 0)
id_ = selected_list.data(index)
self.selected_list.append(id_)
ids_list += f"'{id_}',"
ids_list = ids_list[:-1]
return ids_list
def manage_workcat_end_accept(self):
""" Get elements from all the tables and update his data """
# Setting values
self.workcat_id_end = qt_tools.getWidgetText(
self.dlg_work_end, self.dlg_work_end.workcat_id_end)
self.enddate = qt_tools.getCalendarDate(self.dlg_work_end,
self.dlg_work_end.enddate)
self.statetype_id_end = qt_tools.get_item_data(
self.dlg_work_end, self.dlg_work_end.cmb_statetype_end, 0)
if self.workcat_id_end in ('null', None):
message = "Please select a workcat id end"
self.controller.show_warning(message)
return
ids_list = self.get_list_selected_id(
self.dlg_work_end.tbl_cat_work_x_arc)
row = None
if ids_list:
sql = (f"SELECT * FROM v_ui_arc_x_relations "
f"WHERE arc_id IN ( {ids_list}) AND arc_state = '1'")
row = self.controller.get_row(sql)
if row:
self.dlg_work = FeatureEndConnecUi()
self.load_settings(self.dlg_work)
self.dlg_work.btn_cancel.clicked.connect(
partial(self.close_dialog_workcat_list, self.dlg_work))
self.dlg_work.btn_accept.clicked.connect(self.exec_downgrade)
self.set_completer()
table_relations = "v_ui_arc_x_relations"
self.dlg_work.arc_id.textChanged.connect(
partial(self.filter_by_id, self.dlg_work.tbl_arc_x_relations,
self.dlg_work.arc_id, table_relations))
self.tbl_arc_x_relations = self.dlg_work.findChild(
QTableView, "tbl_arc_x_relations")
self.tbl_arc_x_relations.setSelectionBehavior(
QAbstractItemView.SelectRows)
filter_ = ""
for row in self.selected_list:
filter_ += f"arc_id = '{row}' OR "
filter_ = filter_[:-3] + ""
filter_ += " AND arc_state = '1' "
self.fill_table(self.tbl_arc_x_relations, table_relations, filter_)
self.tbl_arc_x_relations.doubleClicked.connect(
partial(self.open_selected_object, self.tbl_arc_x_relations))
self.open_dialog(self.dlg_work, dlg_name='feature_end_connec')
# TODO: Function update_geom_type() don't use parameter ids_list
else:
# Update tablename of every geom_type
ids_list = self.get_list_selected_id(
self.dlg_work_end.tbl_cat_work_x_arc)
self.update_geom_type("arc", ids_list)
ids_list = self.get_list_selected_id(
self.dlg_work_end.tbl_cat_work_x_node)
self.update_geom_type("node", ids_list)
ids_list = self.get_list_selected_id(
self.dlg_work_end.tbl_cat_work_x_connec)
self.update_geom_type("connec", ids_list)
ids_list = self.get_list_selected_id(
self.dlg_work_end.tbl_cat_work_x_element)
self.update_geom_type("element", ids_list)
if str(self.project_type) == 'ud':
ids_list = self.get_list_selected_id(
self.dlg_work_end.tbl_cat_work_x_gully)
self.update_geom_type("gully", ids_list)
self.manage_close(self.dlg_work_end,
self.table_object,
self.cur_active_layer,
force_downgrade=True)
# Remove selection for all layers in TOC
for layer in self.iface.mapCanvas().layers():
if layer.type() == layer.VectorLayer:
layer.removeSelection()
self.iface.mapCanvas().refresh()
def update_geom_type(self, geom_type, ids_list):
""" Get elements from @geom_type and update his corresponding table """
tablename = "v_edit_" + geom_type
if self.selected_list is None:
return
sql = ""
for id_ in self.selected_list:
sql += (
f"UPDATE {tablename} "
f"SET state = '0', state_type = '{self.statetype_id_end}', workcat_id_end = '{self.workcat_id_end}', "
f"enddate = '{self.enddate}' "
f"WHERE {geom_type}_id = '{id_}';\n")
if sql != "":
status = self.controller.execute_sql(sql, log_sql=False)
if status:
self.controller.show_info("Features updated successfully!")
def fill_table(self, widget, table_name, filter_):
""" Set a model with selected filter.
Attach that model to selected table """
if self.schema_name not in table_name:
table_name = self.schema_name + "." + table_name
# Set model
self.model = QSqlTableModel()
self.model.setTable(table_name)
self.model.setEditStrategy(QSqlTableModel.OnManualSubmit)
if filter_:
self.model.setFilter(filter_)
self.model.setSort(0, 0)
self.model.select()
# Check for errors
if self.model.lastError().isValid():
self.controller.show_warning(self.model.lastError().text())
# Attach model to table view
widget.setModel(self.model)
def open_selected_object(self, widget):
""" Open object form with selected record of the table """
selected_list = widget.selectionModel().selectedRows()
if len(selected_list) == 0:
message = "Any record selected"
self.controller.show_warning(message)
return
row = selected_list[0].row()
feature_id = widget.model().record(row).value("arc_id")
self.open_arc_form(feature_id)
def open_arc_form(self, arc_id):
""" Open form corresponding to start or end node of the current arc """
# Get sys_feature_cat.id from cat_feature.id
sql = (f"SELECT sys_type"
f" FROM v_edit_arc"
f" WHERE arc_id = '{arc_id}'")
row = self.controller.get_row(sql)
if not row:
return
arc_type = row[0].lower()
arc_table = "v_edit_man_" + arc_type
layer_arc = self.controller.get_layer_by_tablename(arc_table)
aux = "\"arc_id\" = "
aux += f"'{arc_id}'"
expr = QgsExpression(aux)
if expr.hasParserError():
message = "Expression Error"
self.controller.show_warning(message,
parameter=expr.parserErrorString())
return
id_list = None
if layer_arc:
# Get a featureIterator from this expression:
it = layer_arc.getFeatures(QgsFeatureRequest(expr))
id_list = [i for i in it]
if id_list:
self.iface.openFeatureForm(layer_arc, id_list[0])
# Zoom to object
if id_list:
canvas = self.iface.mapCanvas()
layer_arc.selectByIds([id_list[0].id()])
canvas.zoomToSelected(layer_arc)
canvas.zoomIn()
def exec_downgrade(self):
message = "Are you sure you want to disconnect this elements?"
title = "Disconnect elements"
answer = self.controller.ask_question(message, title)
if not answer:
return
# Update tablename of every geom_type
ids_list = self.get_list_selected_id(
self.dlg_work_end.tbl_cat_work_x_arc)
self.update_geom_type("arc", ids_list)
self.canvas.refresh()
self.dlg_work.close()
self.manage_workcat_end_accept()
def set_completer(self):
""" Set autocompleters of the form """
# Adding auto-completion to a QLineEdit - visit_id
self.completer = QCompleter()
self.dlg_work.arc_id.setCompleter(self.completer)
model = QStringListModel()
model.setStringList(self.selected_list)
self.completer.setModel(model)
def filter_by_id(self, table, widget_txt, tablename):
id_ = qt_tools.getWidgetText(self.dlg_work, widget_txt)
if id_ != 'null':
expr = f" arc_id = '{id_}'"
# Refresh model with selected filter
table.model().setFilter(expr)
table.model().select()
else:
self.fill_table_relations(table,
self.schema_name + "." + tablename)
def fill_table_relations(self, widget, table_name):
""" Set a model with selected filter. Attach that model to selected table """
if self.schema_name not in table_name:
table_name = self.schema_name + "." + table_name
filter_ = ""
for row in self.selected_list:
filter_ += f"arc_id = '{row}' OR "
filter_ = filter_[:-3] + ""
filter_ += " AND arc_state = '1' "
# Set model
model = QSqlTableModel()
model.setTable(table_name)
model.setEditStrategy(QSqlTableModel.OnManualSubmit)
model.setFilter(filter_)
model.select()
# Check for errors
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
# Attach model to table view
widget.setModel(model)
widget.show()
def close_dialog_workcat_list(self, dlg=None):
""" Close dialog """
try:
self.save_settings(dlg)
dlg.close()
map_tool = self.canvas.mapTool()
# If selected map tool is from the plugin, set 'Pan' as current one
if map_tool.toolName() == '':
self.iface.actionPan().trigger()
except AttributeError:
pass
self.open_dialog(self.dlg_work_end)
def manage_close(self,
dialog,
table_object,
cur_active_layer=None,
force_downgrade=False,
show_warning=False):
""" Close dialog and disconnect snapping """
self.close_dialog(dialog)
self.hide_generic_layers(excluded_layers=["v_edit_element"])
self.disconnect_snapping()
self.disconnect_signal_selection_changed()
if force_downgrade:
sql = ("SELECT feature_type, feature_id, log_message "
"FROM audit_log_data "
"WHERE fid = 128 AND cur_user = current_user")
rows = self.controller.get_rows(sql, log_sql=False)
ids_ = ""
if rows:
for row in rows:
ids_ += str(row[1]) + ", "
state_statetype = str(row['log_message']).split(',')
sql = (
f"UPDATE {row[0].lower()} "
f"SET state = '{state_statetype[0]}', state_type = '{state_statetype[1]}' "
f"WHERE {row[0]}_id = '{row[1]}';")
self.controller.execute_sql(sql)
ids_ = ids_[:-2]
if show_warning and len(ids_) != 0:
msg = 'These items could not be downgrade to state 0'
self.controller.show_info_box(msg,
title="Warning",
inf_text=str(ids_))
sql = ("DELETE FROM audit_log_data "
"WHERE fid = 128 AND cur_user = current_user")
self.controller.execute_sql(sql)
self.set_edit_arc_downgrade_force('False')
self.canvas.refresh()
def new_workcat(self):
self.dlg_new_workcat = InfoWorkcatUi()
self.load_settings(self.dlg_new_workcat)
qt_tools.setCalendarDate(self.dlg_new_workcat,
self.dlg_new_workcat.builtdate, None, True)
table_object = "cat_work"
self.set_completer_widget(table_object,
self.dlg_new_workcat.cat_work_id, 'id')
# Set signals
self.dlg_new_workcat.btn_accept.clicked.connect(
partial(self.manage_new_workcat_accept, table_object))
self.dlg_new_workcat.btn_cancel.clicked.connect(
partial(self.close_dialog, self.dlg_new_workcat))
# Open dialog
self.open_dialog(self.dlg_new_workcat, dlg_name='info_workcat')
def manage_new_workcat_accept(self, table_object):
""" Insert table 'cat_work'. Add cat_work """
# Get values from dialog
values = ""
fields = ""
cat_work_id = qt_tools.getWidgetText(self.dlg_new_workcat,
self.dlg_new_workcat.cat_work_id)
if cat_work_id != "null":
fields += 'id, '
values += f"'{cat_work_id}', "
descript = qt_tools.getWidgetText(self.dlg_new_workcat, "descript")
if descript != "null":
fields += 'descript, '
values += f"'{descript}', "
link = qt_tools.getWidgetText(self.dlg_new_workcat, "link")
if link != "null":
fields += 'link, '
values += f"'{link}', "
workid_key_1 = qt_tools.getWidgetText(self.dlg_new_workcat,
"workid_key_1")
if workid_key_1 != "null":
fields += 'workid_key1, '
values += f"'{workid_key_1}', "
workid_key_2 = qt_tools.getWidgetText(self.dlg_new_workcat,
"workid_key_2")
if workid_key_2 != "null":
fields += 'workid_key2, '
values += f"'{workid_key_2}', "
builtdate = self.dlg_new_workcat.builtdate.dateTime().toString(
'yyyy-MM-dd')
if builtdate != "null":
fields += 'builtdate, '
values += f"'{builtdate}', "
if values == "":
return
fields = fields[:-2]
values = values[:-2]
if cat_work_id == 'null':
msg = "Work_id field is empty"
self.controller.show_info_box(msg, "Warning")
else:
# Check if this element already exists
sql = (f"SELECT DISTINCT(id)"
f" FROM {table_object}"
f" WHERE id = '{cat_work_id}'")
row = self.controller.get_row(sql, log_info=False, log_sql=True)
if row is None:
sql = f"INSERT INTO cat_work ({fields}) VALUES ({values})"
self.controller.execute_sql(sql, log_sql=True)
sql = "SELECT id FROM cat_work ORDER BY id"
rows = self.controller.get_rows(sql)
if rows:
qt_tools.fillComboBox(self.dlg_work_end,
self.dlg_work_end.workcat_id_end,
rows)
aux = self.dlg_work_end.workcat_id_end.findText(
str(cat_work_id))
self.dlg_work_end.workcat_id_end.setCurrentIndex(aux)
self.close_dialog(self.dlg_new_workcat)
else:
msg = "This Workcat already exist"
self.controller.show_info_box(msg, "Warning")
def fill_table_unit(self, qtable, table_name, expr_filter=None):
""" Fill table @widget filtering query by @workcat_id
Set a model with selected filter.
Attach that model to selected table
@setEditStrategy:
0: OnFieldChange
1: OnRowChange
2: OnManualSubmit
"""
expr = None
if expr_filter:
# Check expression
(is_valid, expr) = self.check_expression(expr_filter) # @UnusedVariable
if not is_valid:
return expr
# Set a model with selected filter expression
if self.schema_name not in table_name:
table_name = self.schema_name + "." + table_name
# Set model
model = QSqlTableModel()
model.setTable(table_name)
model.setEditStrategy(QSqlTableModel.OnFieldChange)
model.setSort(0, 0)
model.select()
# Check for errors
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
# Attach model to table view
if expr:
qtable.setModel(model)
qtable.model().setFilter(expr_filter)
else:
qtable.setModel(model)
return expr
def fill_table_relations(self, widget, table_name):
""" Set a model with selected filter. Attach that model to selected table """
if self.schema_name not in table_name:
table_name = self.schema_name + "." + table_name
filter_ = ""
for row in self.selected_list:
filter_ += f"arc_id = '{row}' OR "
filter_ = filter_[:-3] + ""
filter_ += " AND arc_state = '1' "
# Set model
model = QSqlTableModel()
model.setTable(table_name)
model.setEditStrategy(QSqlTableModel.OnManualSubmit)
model.setFilter(filter_)
model.select()
# Check for errors
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
# Attach model to table view
widget.setModel(model)
widget.show()
def fill_table_prices(self, qtable, table_view, new_camp, set_edit_triggers=QTableView.NoEditTriggers):
""" Set a model with selected filter and attach it to selected table
@setEditStrategy: 0: OnFieldChange, 1: OnRowChange, 2: OnManualSubmit
"""
if self.schema_name not in table_view:
table_view = self.schema_name + "." + table_view
# Set model
model = QSqlTableModel()
model.setTable(table_view)
model.setEditStrategy(QSqlTableModel.OnFieldChange)
model.setSort(2, 0)
model.select()
qtable.setEditTriggers(set_edit_triggers)
# Check for errors
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
return
# Attach model to table view
expr = f"campaign_id = '{new_camp}'"
qtable.setModel(model)
qtable.model().setFilter(expr)
class hsrrProcessorDockWidget(QDockWidget, FORM_CLASS):
closingPlugin = pyqtSignal()
def __init__(self, parent=None):
super(hsrrProcessorDockWidget, self).__init__(parent)
self.setupUi(self)
self.connect_button.clicked.connect(self.connect)
self.dd = hsrr_processor_dd.hsrr_dd(self)
self.prepare_database_button.clicked.connect(self.prepare_database)
self.rw = routes_widget(self, self.dd, 'hsrr.routes',
self.readings_box, self.network_box,
self.run_fieldbox, self.f_line_fieldbox,
self.sec_fieldbox)
self.rw_placeholder.addWidget(self.rw)
#self.tabs.insertTab(2,self.rw,'Fitting')
self.upload_csv_button.clicked.connect(self.upload_runs_dialog)
self.upload_folder_button.clicked.connect(self.upload_folder_dialog)
self.open_help_button.clicked.connect(self.open_help)
self.init_run_menu()
self.init_requested_menu()
self.rw.refit.connect(lambda: print('refit'))
def connect(self):
if self.dd.exec_():
if self.dd.connected:
self.database_label.setText('Connected to %s' %
(self.dd.db.databaseName()))
self.connect_run_info()
self.connect_coverage()
self.refresh_run_info()
else:
self.database_label.setText('Not Connected')
def coverage_show_all(self):
self.requested_model.setFilter('')
self.requested_model.select()
def coverage_show_missing(self):
self.requested_model.setFilter("coverage=0")
self.requested_model.select()
#opens help/index.html in default browser
def open_help(self):
help_path = os.path.join(os.path.dirname(__file__), 'help',
'index.html')
help_path = 'file:///' + os.path.abspath(help_path)
QDesktopServices.openUrl(QUrl(help_path))
def connect_run_info(self):
self.run_info_model = QSqlTableModel(db=self.dd.db)
self.run_info_model.setTable('hsrr.run_info')
self.run_info_model.setSort(self.run_info_model.fieldIndex("run"),
Qt.AscendingOrder)
self.run_info_model.setEditStrategy(QSqlTableModel.OnFieldChange)
self.run_info_view.setModel(self.run_info_model)
def check_connected(self):
if self.dd.con:
return True
else:
iface.messageBar().pushMessage(
'fitting tool: Not connected to database')
return False
def upload_runs(self, runs):
for f in runs:
r = self.dd.upload_run_csv(f)
if r == True:
self.upload_log.appendPlainText('sucessfully uploaded %s' %
(f))
else:
self.upload_log.appendPlainText('error uploading %s:%s' %
(f, str(r)))
self.update()
self.refresh_run_info()
def upload_runs_dialog(self):
if self.check_connected():
files = file_dialogs.load_files_dialog('.xls',
'upload spreadsheets')
if files:
for f in files:
self.upload_runs(files)
def upload_folder_dialog(self):
folder = file_dialogs.load_directory_dialog(
'.xls', 'upload all .xls in directory')
if folder:
self.upload_runs(file_dialogs.filter_files(folder, '.xls'))
def closeEvent(self, event):
self.dd.disconnect()
self.closingPlugin.emit()
event.accept()
def after_refit(self):
self.coverage_model.select()
def connect_coverage(self):
# self.requested_model = QSqlTableModel(db=self.dd.db)
self.requested_model = betterTableModel(db=self.dd.db)
self.requested_model.setEditStrategy(QSqlTableModel.OnFieldChange)
self.requested_model.setTable('hsrr.requested')
self.requested_model.setEditable(False) #set all cols uneditable
self.requested_model.setColEditable(
self.requested_model.fieldIndex("note"),
True) #make note col editable
self.requested_model.setSort(self.requested_model.fieldIndex("sec"),
Qt.AscendingOrder)
self.requested_view.setModel(self.requested_model)
self.requested_view.setColumnHidden(
self.requested_model.fieldIndex("pk"), True) #hide pk column
self.show_all_button.clicked.connect(self.coverage_show_all)
self.show_missing_button.clicked.connect(self.coverage_show_missing)
self.rw.refit.connect(self.requested_model.select)
if self.show_missing_button.isChecked():
self.coverage_show_missing()
else:
self.coverage_show_all()
self.requested_view.resizeColumnsToContents()
def prepare_database(self):
if self.check_connected():
msgBox = QMessageBox()
msgBox.setText(
"DON'T USE THIS PARTWAY THROUGH THE JOB! because this will erase any data in tables used by this plugin."
)
msgBox.setInformativeText("Continue?")
msgBox.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
msgBox.setDefaultButton(QMessageBox.No)
i = msgBox.exec_()
if i == QMessageBox.Yes:
self.dd.setup_database()
iface.messageBar().pushMessage(
'fitting tool: prepared database')
#drop selected run of run_info table
def drop_run(self):
r = self.run_box.currentText()
self.dd.sql("delete from run_info where run='{run}'", {'run': r})
self.rw.get_runs()
#for requested view
def init_run_menu(self):
self.run_info_menu = QMenu()
act = self.run_info_menu.addAction('drop run')
act.triggered.connect(lambda: self.dd.drop_runs([
str(i.data())
for i in self.run_info_view.selectionModel().selectedRows(0)
])) # selectedRows(0) returns column 0 (sec)
act.triggered.connect(
self.refresh_run_info) # selectedRows(0) returns column 0 (sec)
self.run_info_view.setContextMenuPolicy(Qt.CustomContextMenu)
self.run_info_view.customContextMenuRequested.connect(
self.show_run_info_menu)
#for requested view
def init_requested_menu(self):
self.requested_menu = QMenu()
act = self.requested_menu.addAction('zoom to section')
act.triggered.connect(lambda: self.select_on_network([
i.data()
for i in self.requested_view.selectionModel().selectedRows()
]))
self.requested_view.setContextMenuPolicy(Qt.CustomContextMenu)
self.requested_view.customContextMenuRequested.connect(
self.show_requested_menu)
def show_run_info_menu(self, pt):
self.run_info_menu.exec_(self.mapToGlobal(pt))
def show_requested_menu(self, pt):
self.requested_menu.exec_(self.mapToGlobal(pt))
def refresh_run_info(self):
self.run_info_model.select()
self.rw.refresh_runs()
#select sec on network
def select_on_network(self, sects):
# inds=self.requested_view.selectionModel().selectedRows()#indexes of column 0
have_network = self.network_box.currentLayer(
) and self.sec_fieldbox.currentField()
if have_network:
select_sections(sects,
self.network_box.currentLayer(),
self.sec_fieldbox.currentField(),
zoom=True)
else:
iface.messageBar().pushMessage(
'fitting tool:network layer§ion field not set')
class grip_testerDockWidget(QDockWidget, FORM_CLASS):
closingPlugin = pyqtSignal()
def __init__(self, parent=None):
super(grip_testerDockWidget, self).__init__(parent)
self.setupUi(self)
self.connect_button.clicked.connect(self.connect)
self.dd = grip_tester_dd.grip_dd(self)
self.s10_button.clicked.connect(self.set_s10)
self.zm3_button.clicked.connect(self.set_zm3)
self.upload_button.clicked.connect(self.upload_run)
self.to_hmd_button.clicked.connect(self.download_hmd)
self.prepare_database_button.clicked.connect(self.prepare_database)
self.search_hmds_button.clicked.connect(self.search_hmds)
self.rw = routes_widget(self, self.dd, 'gtest.routes',
self.readings_box, self.network_box,
self.run_fieldbox, self.f_line_fieldbox,
self.sec_fieldbox)
self.rw_placeholder.addWidget(self.rw)
#self.tabs.insertTab(2,self.rw,'Fitting')
self.upload_csv_button.clicked.connect(self.upload_run_csvs)
self.init_requested_menu()
self.init_missing_menu()
self.init_run_menu()
self.open_help_button.clicked.connect(self.open_help)
self.copy_lengths_button.clicked.connect(
lambda: copy_functions.copy_all(self.lengths_view))
self.copy_missing_button.clicked.connect(
lambda: copy_functions.copy_all(self.missing_view))
self.copy_benchmarks_button.clicked.connect(
lambda: copy_functions.copy_all(self.benchmarks_view))
self.upload_folder_button.clicked.connect(self.upload_folder)
def connect(self):
if self.dd.exec_():
if self.dd.connected:
self.database_label.setText('Connected to %s' %
(self.dd.db.databaseName()))
self.dd.sql('set search_path to gtest,public;')
self.connect_coverage()
self.connect_lengths()
self.connect_missing()
self.connect_benchmarks()
self.rw.refresh_runs()
self.connect_run_info()
self.tabs.currentChanged.connect(self.refresh_coverage)
self.coverage_toolbox.currentChanged.connect(
self.refresh_coverage)
self.requested_model.dataChanged.connect(
lambda: self.missing_model.setQuery(self.missing_model.
query()))
else:
self.database_label.setText('Not Connected')
#opens help/index.html in default browser
def open_help(self):
help_path = os.path.join(os.path.dirname(__file__), 'help',
'index.html')
help_path = 'file:///' + os.path.abspath(help_path)
QDesktopServices.openUrl(QUrl(help_path))
def connect_run_info(self):
self.run_info_model = QSqlTableModel(db=self.dd.db)
self.run_info_model.setTable('gtest.run_info')
self.run_info_model.setSort(self.run_info_model.fieldIndex("run"),
Qt.AscendingOrder)
self.run_info_model.setEditStrategy(QSqlTableModel.OnFieldChange)
self.run_info_view.setModel(self.run_info_model)
self.run_info_model.select()
def connect_coverage(self):
# self.requested_model = QSqlTableModel(db=self.dd.db)
self.requested_model = betterTableModel(db=self.dd.db)
self.requested_model.setEditStrategy(QSqlTableModel.OnFieldChange)
self.requested_model.setTable('gtest.requested')
self.requested_model.setEditable(False) #set all cols uneditable
self.requested_model.setColEditable(
self.requested_model.fieldIndex("note"),
True) #make note col editable
self.requested_model.setSort(self.requested_model.fieldIndex("sec"),
Qt.AscendingOrder)
self.requested_view.setModel(self.requested_model)
self.requested_view.setColumnHidden(
self.requested_model.fieldIndex("pk"), True) #hide pk column
self.requested_view.setColumnHidden(
self.requested_model.fieldIndex("coverage"),
True) #hide coverage column
#self.show_all_button.clicked.connect(self.coverage_show_all)
#self.show_missing_button.clicked.connect(self.coverage_show_missing)
self.show_missing_button.clicked.connect(self.filter_requested)
self.show_all_button.clicked.connect(self.filter_requested)
self.partly_missing_button.clicked.connect(self.filter_requested)
self.filter_requested()
self.requested_view.resizeColumnsToContents()
def filter_requested(self):
if self.show_missing_button.isChecked():
self.requested_model.setFilter("cardinality(hmds)=0")
if self.show_all_button.isChecked():
self.requested_model.setFilter('')
if self.partly_missing_button.isChecked():
self.requested_model.setFilter(
'cardinality(hmds)>0 and (select count (sec) from gtest.resized where gtest.resized.sec=gtest.requested.sec and gtest.resized.reversed=gtest.requested.reversed and sfc is null)>1'
)
self.requested_model.select()
def connect_benchmarks(self):
self.benchmarks_model = QSqlQueryModel()
self.benchmarks_model.setQuery(
"select early,mid,late,com from gtest.benchmarks_view order by sec,xsp,s_ch",
self.dd.db)
self.benchmarks_view.setModel(self.benchmarks_model)
self.benchmarks_view.resizeColumnsToContents()
def refresh_coverage(self):
self.requested_model.select()
self.missing_model.setQuery(self.missing_model.query())
self.lengths_model.setQuery(self.lengths_model.query())
self.benchmarks_model.setQuery(self.benchmarks_model.query())
def connect_missing(self):
self.missing_model = QSqlQueryModel()
self.missing_model.setQuery("select * from gtest.missing_view",
self.dd.db)
self.missing_view.setModel(self.missing_model)
self.missing_view.resizeColumnsToContents()
def connect_lengths(self):
self.lengths_model = QSqlQueryModel()
self.lengths_model.setQuery("select * from gtest.lengths", self.dd.db)
self.lengths_view.setModel(self.lengths_model)
self.lengths_view.resizeColumnsToContents()
#make_copyable(self.lengths_view)
def check_connected(self):
if self.dd.con:
return True
else:
iface.messageBar().pushMessage(
'fitting tool: Not connected to database')
return False
def upload_run_csvs(self):
if self.check_connected():
files = file_dialogs.load_files_dialog('.csv', 'upload csv')
if files:
for f in files:
#r=self.dd.upload_run_csv(f)
r = self.dd.upload_run(f)
if r == True:
self.upload_log.appendPlainText(
'sucessfully uploaded %s' % (f))
else:
self.upload_log.appendPlainText(
'error uploading %s:%s' % (f, str(r)))
# self.upload_log.repaint()
self.update()
#processEvents()
self.run_info_model.select()
self.rw.refresh_runs()
def upload_folder(self):
folder = file_dialogs.load_directory_dialog(
'.csv', 'upload all .csv in directory')
if folder:
self.dd.upload_runs(file_dialogs.filter_files(folder, '.csv'))
def closeEvent(self, event):
self.dd.disconnect()
self.closingPlugin.emit()
event.accept()
def upload_run(self):
if self.check_connected():
if self.run_number.text() == '':
iface.messageBar().pushMessage(
'fitting tool: run number not set')
else:
self.dd.sql(
"insert into run_info select '{run}',to_date('{date}','dd-mm-yyyy') where not exists (select run from run_info where run='{run}')",
{
'run':
self.run_number.text(),
'date':
str(self.survey_date.date().day()) + '-' +
str(self.survey_date.date().month()) + '-' +
str(self.survey_date.date().year())
})
if self.s10.text() != '':
try:
upload_s10(self.run_number.text(), self.s10.text(),
db_to_con(self.dd.db))
iface.messageBar().pushMessage(
'fitting tool: uploaded s10:' +
str(self.s10.text()))
except Exception as e:
iface.messageBar().pushMessage(
'fitting tool: error uploading s10:' +
self.s10.text() + ': ' + str(e))
if self.zm3.text() != '':
try: #zm3,con
upload_zm3(self.run_number.text(), self.zm3.text(),
db_to_con(self.dd.db))
iface.messageBar().pushMessage(
'fitting tool: uploaded zm3:' + self.zm3.text())
except Exception as e:
iface.messageBar().pushMessage(
'fitting tool: error uploading zm3:' +
self.zm3.text() + ': ' + str(e))
self.rw.refresh_runs()
def set_s10(self):
s = file_dialogs.load_file_dialog('.s10', 'load .s10')
if s:
self.s10.setText(s)
def set_zm3(self):
s = file_dialogs.load_file_dialog('.zm3', 'load .zm3')
if s:
self.zm3.setText(s)
def download_hmd(self):
if self.check_connected():
s = file_dialogs.save_file_dialog('.hmd')
print(s)
if s:
if self.include_snode_box.isChecked():
to_hmd_snode(s, self.forward_box.isChecked(),
self.reversed_box.isChecked(), self.dd.db)
else:
to_hmd(s, self.forward_box.isChecked(),
self.reversed_box.isChecked(), self.dd.db)
iface.messageBar().pushMessage('fitting tool: saved:' + s)
def prepare_database(self):
if self.check_connected():
msgBox = QMessageBox()
msgBox.setText(
"DON'T USE THIS PARTWAY THROUGH THE JOB! because this will erase any data in tables used by this plugin."
)
msgBox.setInformativeText("Continue?")
msgBox.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
msgBox.setDefaultButton(QMessageBox.No)
i = msgBox.exec_()
if i == QMessageBox.Yes:
self.dd.setup_database()
iface.messageBar().pushMessage(
'fitting tool: prepared database')
#drop selected run of run_info table
def drop_run(self):
r = self.run_box.currentText()
self.dd.sql("delete from run_info where run='{run}'", {'run': r})
self.rw.get_runs()
def search_hmds(self):
hmds = file_dialogs.load_files_dialog(ext='.hmd',
caption='search hmds')
if hmds and self.check_connected():
self.dd.search_hmds(hmds, reset=True)
iface.messageBar().pushMessage('fitting tool:searched hmds: ' +
','.join(hmds))
self.missing_model.setQuery(
"select * from missing_view") #refresh missing_model
self.lengths_model.setQuery("select * from lengths")
self.requested_model.select()
#for requested view
def init_requested_menu(self):
self.requested_menu = QMenu()
requested_zoom_act = self.requested_menu.addAction('zoom to section')
requested_zoom_act.triggered.connect(lambda: self.select_on_network([
i.data()
for i in self.requested_view.selectionModel().selectedRows()
]))
copy_all_requested_act = self.requested_menu.addAction(
'copy all rows to clipboard')
copy_all_requested_act.triggered.connect(
lambda: copy_functions.copy_all(self.requested_view))
self.requested_view.setContextMenuPolicy(Qt.CustomContextMenu)
self.requested_view.customContextMenuRequested.connect(
self.show_requested_menu)
#for missing_view
def init_missing_menu(self):
self.missing_menu = QMenu()
act = self.missing_menu.addAction('zoom to section')
act.triggered.connect(lambda: self.select_on_network([
i.data()
for i in self.missing_view.selectionModel().selectedRows(1)
])) # selectedRows(1) returns column 1 (sec)
self.missing_view.setContextMenuPolicy(Qt.CustomContextMenu)
self.missing_view.customContextMenuRequested.connect(
self.show_missing_menu)
#for run_info_view
def init_run_menu(self):
self.run_info_menu = QMenu()
act = self.run_info_menu.addAction('drop run')
act.triggered.connect(lambda: self.dd.drop_runs([
str(i.data())
for i in self.run_info_view.selectionModel().selectedRows(0)
])) # selectedRows(0) returns column 0 (run)
act.triggered.connect(
self.refresh_runs) # selectedRows(0) returns column 0 (sec)
self.run_info_view.setContextMenuPolicy(Qt.CustomContextMenu)
self.run_info_view.customContextMenuRequested.connect(
self.show_run_info_menu)
def show_requested_menu(self, pt):
self.requested_menu.exec_(self.mapToGlobal(pt))
def show_missing_menu(self, pt):
self.missing_menu.exec_(self.mapToGlobal(pt))
def show_run_info_menu(self, pt):
self.run_info_menu.exec_(self.mapToGlobal(pt))
def refresh_runs(self):
self.rw.get_runs()
self.run_info_model.select()
#select sec on network
def select_on_network(self, sects):
# inds=self.requested_view.selectionModel().selectedRows()#indexes of column 0
have_network = self.network_box.currentLayer(
) and self.sec_fieldbox.currentField()
if have_network:
select_sections(sects,
self.network_box.currentLayer(),
self.sec_fieldbox.currentField(),
zoom=True)
else:
iface.messageBar().pushMessage(
'fitting tool:network layer§ion field not set')