def save_tab_analysis(self): """ Save tab from tab 'Analysis' """ # super(NodeDialog, self).save_tab_analysis() if self.epa_type == "JUNCTION": values = [] sql = "UPDATE " + self.schema_name + "." + self.epa_table + " SET " for i in range(len(self.fields_junction)): widget_name = self.epa_table + "_" + self.fields_junction[i] value = utils_giswater.getWidgetText(widget_name, True) values.append(value) sql += self.fields_junction[i] + " = " + str(values[i]) + ", " sql = sql[:-2] sql += " WHERE node_id = '" + self.id + "'" self.dao.execute_sql(sql) if self.epa_type == "TANK": values = [] sql = "UPDATE " + self.schema_name + "." + self.epa_table + " SET " for i in range(len(self.fields_tank)): widget_name = self.epa_table + "_" + self.fields_tank[i] value = utils_giswater.getWidgetText(widget_name, True) values.append(value) sql += self.fields_tank[i] + " = " + str(values[i]) + ", " sql = sql[:-2] sql += " WHERE node_id = '" + self.id + "'" self.dao.execute_sql(sql)
def init_config_arc(self): ''' Custom form initial configuration for 'Arc' ''' # Define class variables self.field_id = "arc_id" self.id = utils_giswater.getWidgetText(self.field_id, False) self.epa_type = utils_giswater.getWidgetText("epa_type", False) if self.epa_type == 'PIPE': self.epa_table = 'inp_pipe' # Get widget controls self.tab_analysis = self.dialog.findChild(QTabWidget, "tab_analysis") self.tab_event = self.dialog.findChild(QTabWidget, "tab_event") self.tab_main = self.dialog.findChild(QTabWidget, "tab_main") # Manage tab visibility self.set_tabs_visibility() # Manage i18n self.translate_form('ws_arc') # Fill combo 'arc type' from 'epa_type' self.fill_arc_type() # Load data from related tables self.load_data() # Set layer in editing mode self.layer.startEditing()
def set_filter_table(self, widget): ''' Get values selected by the user and sets a new filter for its table model ''' # Get selected dates date_from = self.date_document_from.date().toString('yyyyMMdd') date_to = self.date_document_to.date().toString('yyyyMMdd') if (date_from > date_to): message = "Selected date interval is not valid" self.controller.show_warning(message, context_name='ui_message') return # Set filter expr = self.field_id+" = '"+self.id+"'" expr+= " AND date >= '"+date_from+"' AND date <= '"+date_to+"'" # Get selected values in Comboboxes doc_type_value = utils_giswater.getWidgetText("doc_type") if doc_type_value != 'null': expr+= " AND doc_type = '"+doc_type_value+"'" doc_tag_value = utils_giswater.getWidgetText("doc_tag") if doc_tag_value != 'null': expr+= " AND tagcat_id = '"+doc_tag_value+"'" doc_user_value = utils_giswater.getWidgetText("doc_user") if doc_user_value != 'null': expr+= " AND user_name = '"+doc_user_value+"'" # Refresh model with selected filter widget.model().setFilter(expr) widget.model().select()
def mg_table_wizard_import_csv(self): # Get selected table, delimiter, and header alias = utils_giswater.getWidgetText(self.dlg.cbo_table) table_name = self.table_dict[alias] delimiter = utils_giswater.getWidgetText(self.dlg.cbo_delimiter) header_status = self.dlg.chk_header.checkState() # Get CSV file. Check if file exists self.file_path = self.dlg.txt_file_path.toPlainText() if not os.path.exists(self.file_path): message = "Selected file not found: "+self.file_path self.controller.show_warning(message, context_name='ui_message' ) return False # Open CSV file for read and copy into database rf = open(self.file_path) sql = "COPY "+self.schema_name+"."+table_name+" FROM STDIN WITH CSV" if (header_status == Qt.Checked): sql+= " HEADER" sql+= " DELIMITER AS '"+delimiter+"'" status = self.dao.copy_expert(sql, rf) if status: self.dao.rollback() msg = "Cannot import CSV into table "+table_name+". Reason:\n"+str(status).decode('utf-8') QMessageBox.warning(None, "Import CSV", self.controller.tr(msg)) return False else: self.dao.commit() message = "Selected CSV has been imported successfully" self.controller.show_info(message, context_name='ui_message' )
def init_config_node(self): ''' Custom form initial configuration for 'Node' ''' # Define class variables self.field_id = "node_id" self.id = utils_giswater.getWidgetText(self.field_id, False) self.node_type = utils_giswater.getWidgetText("node_type", False) self.nodecat_id = utils_giswater.getWidgetText("nodecat_id", False) self.epa_type = utils_giswater.getWidgetText("epa_type", False) # Get widget controls self.tab_analysis = self.dialog.findChild(QTabWidget, "tab_analysis") self.tab_event = self.dialog.findChild(QTabWidget, "tab_event") self.tab_main = self.dialog.findChild(QTabWidget, "tab_main") # Manage tab visibility self.set_tabs_visibility() # Manage i18n self.translate_form('ws_node') # Define and execute query to populate combo 'node_type_dummy' self.fill_node_type_id() # Load data from related tables self.load_data() # Set layer in editing mode self.layer.startEditing()
def init_config_form(self): ''' Custom form initial configuration ''' # Define local variables context_name = "ws_arc" table_element = "v_ui_element_x_arc" table_document = "v_ui_doc_x_arc" # Define class variables self.field_id = "arc_id" self.id = utils_giswater.getWidgetText(self.field_id, False) self.filter = self.field_id+" = '"+str(self.id)+"'" self.arc_type = utils_giswater.getWidgetText("cat_arctype_id", False) self.arccat_id = utils_giswater.getWidgetText("arccat_id", False) self.epa_type = utils_giswater.getWidgetText("epa_type", False) self.tab_analysis = self.dialog.findChild(QTabWidget, "tab_analysis") self.tab_event = self.dialog.findChild(QTabWidget, "tab_event") self.tab_event_2 = self.dialog.findChild(QTabWidget, "tab_event_2") self.tab_main = self.dialog.findChild(QTabWidget, "tab_main") self.tbl_info = self.dialog.findChild(QTableView, "tbl_info") self.tbl_document = self.dialog.findChild(QTableView, "tbl_document") self.tbl_rtc = self.dialog.findChild(QTableView, "tbl_rtc") # Manage tab visibility self.set_tabs_visibility() # Manage i18n self.translate_form(context_name) # Define and execute query to populate combo 'cat_arctype_id_dummy' self.fill_arc_type_id() # Load data from related tables self.load_data() # Set layer in editing mode self.layer.startEditing() # Fill the info table self.fill_table(self.tbl_info, self.schema_name+"."+table_element, self.filter) # Configuration of info table self.set_configuration(self.tbl_info, table_element) # Fill the tab Document self.fill_tbl_document(self.tbl_document, self.schema_name+"."+table_document, self.filter) # Configuration of table document self.set_configuration(self.tbl_document, table_document) # Set signals btn_element_delete = self.dialog.findChild(QPushButton, "btn_element_delete") btn_doc_delete = self.dialog.findChild(QPushButton, "btn_doc_delete") if btn_element_delete: btn_element_delete.clicked.connect(partial(self.delete_records, self.tbl_info, table_element)) if btn_doc_delete: btn_doc_delete.clicked.connect(partial(self.delete_records, self.tbl_document, table_document))
def fill_geomcat_id(self): catalog_id = utils_giswater.getWidgetText(self.dlg_cat.id) self.close_dialog(self.dlg_cat) utils_giswater.setDialog(self.dlg) utils_giswater.setWidgetEnabled(self.dlg.node_nodecat_id, True) utils_giswater.setWidgetText(self.dlg.node_nodecat_id, catalog_id)
def generic_zoom(self, fieldname, combo, field_index=0): """ Get selected element from the combo, and returns a feature request expression """ # Get selected element from combo element = utils_giswater.getWidgetText(combo) if element == 'null': return None elem = combo.itemData(combo.currentIndex()) if not elem: # that means that user has edited manually the combo but the element # does not correspond to any combo element message = 'Element {} does not exist'.format(element) self.controller.show_warning(message) return None # Check if the expression is valid aux = fieldname + " = '" + str(elem[field_index]) + "'" expr = QgsExpression(aux) if expr.hasParserError(): message = expr.parserErrorString() + ": " + aux self.controller.show_warning(message) return return expr
def fill_filter2(self, wsoftware, geom_type): # Get values from filters mats = utils_giswater.getWidgetText(self.dlg_cat.matcat_id) # Set SQL query sql_where = "" sql = ("SELECT DISTINCT(" + self.field2 + ")" " FROM " + self.schema_name + ".cat_" + geom_type) # Build SQL filter if mats != "null": if sql_where == "": sql_where = " WHERE" sql_where += " matcat_id = '" + mats + "'" if wsoftware == 'ws' and self.node_type_text is not None: if sql_where == "": sql_where = " WHERE" else: sql_where += " AND" sql_where += " " + geom_type + "type_id = '" + self.node_type_text + "'" sql += sql_where + " ORDER BY " + self.field2 rows = self.controller.get_rows(sql) utils_giswater.fillComboBox(self.dlg_cat.filter2, rows) self.fill_filter3(wsoftware, geom_type)
def delete_feature_at_plan_psector(self, geom_type, list_id, plan_om): """ Delete features_id to table plan_@geom_type_x_psector""" value = utils_giswater.getWidgetText(self.dlg.psector_id) sql = ("DELETE FROM " + self.schema_name + "." + plan_om + "_psector_x_" + geom_type + "" " WHERE " + geom_type + "_id IN (" + list_id + ") AND psector_id = '" + str(value) + "'") self.controller.execute_sql(sql)
def generate_csv(self, path, viewname, previous_dialog): # Get columns name in order of the table sql = ("SELECT column_name FROM information_schema.columns" " WHERE table_name = '" + "v_" + self.plan_om + "_psector'" " AND table_schema = '" + self.schema_name.replace('"', '') + "'" " ORDER BY ordinal_position") rows = self.controller.get_rows(sql) columns = [] for i in range(0, len(rows)): column_name = rows[i] columns.append(str(column_name[0])) sql = ("SELECT * FROM " + self.schema_name + "." + viewname + "" " WHERE psector_id = '" + str(utils_giswater.getWidgetText(previous_dialog.psector_id)) + "'") rows = self.controller.get_rows(sql) all_rows = [] all_rows.append(columns) for i in rows: all_rows.append(i) with open(path, "w") as output: writer = csv.writer(output, lineterminator='\n') writer.writerows(all_rows)
def open_node_form(self, idx): """ Open form corresponding to start or end node of the current arc """ field_node = "node_" + str(idx) widget = self.dialog.findChild(QLineEdit, field_node) node_id = utils_giswater.getWidgetText(self.dialog, widget) if not widget: self.controller.log_info("widget not found", parameter=field_node) return # get pointer of node by ID aux = "\"node_id\" = " aux += "'" + str(node_id) + "'" expr = QgsExpression(aux) if expr.hasParserError(): message = "Expression Error" self.controller.show_warning(message, parameter=expr.parserErrorString()) return # List of nodes from node_type_cat_type - nodes which we are using for feature_cat in self.feature_cat.itervalues(): if feature_cat.type == 'NODE': layer = self.controller.get_layer_by_layername( feature_cat.layername) if layer: # Get a featureIterator from this expression: it = layer.getFeatures(QgsFeatureRequest(expr)) id_list = [i for i in it] if id_list: self.iface.openFeatureForm(layer, id_list[0])
def open_web_browser(self, widget): """ Display url using the default browser """ url = utils_giswater.getWidgetText(widget) if url == 'null': url = 'www.giswater.org' webbrowser.open(url)
def exist_object(self, table_object): """ Check if selected object (document or element) already exists """ # Reset list of selected records self.reset_lists() field_object_id = "id" if table_object == "element": field_object_id = table_object + "_id" object_id = utils_giswater.getWidgetText(table_object + "_id") # Check if we already have data with selected object_id sql = ("SELECT * " " FROM " + self.schema_name + "." + str(table_object) + "" " WHERE " + str(field_object_id) + " = '" + str(object_id) + "'") row = self.controller.get_row(sql, log_info=False) # If object_id not found: Clear data if not row: self.reset_widgets(table_object) if hasattr(self, 'single_tool_mode'): # some tools can work differently if standalone or integrated in # another tool if self.single_tool_mode: self.remove_selection(True) else: self.remove_selection(True) self.reset_model(table_object, "arc") self.reset_model(table_object, "node") self.reset_model(table_object, "connec") self.reset_model(table_object, "element") if self.project_type == 'ud': self.reset_model(table_object, "gully") if table_object != 'doc': self.dlg.enddate.setEnabled(False) return if table_object != 'doc': self.dlg.enddate.setEnabled(True) # Fill input widgets with data of the @row self.fill_widgets(table_object, row) # Check related 'arcs' self.get_records_geom_type(table_object, "arc") # Check related 'nodes' self.get_records_geom_type(table_object, "node") # Check related 'connecs' self.get_records_geom_type(table_object, "connec") # Check related 'elements' self.get_records_geom_type(table_object, "element") # Check related 'gullys' if self.project_type == 'ud': self.get_records_geom_type(table_object, "gully")
def exist_object(self, dialog, table_object): """ Check if selected object (document or element) already exists """ # Reset list of selected records self.reset_lists() field_object_id = "id" if table_object == "element": field_object_id = table_object + "_id" object_id = utils_giswater.getWidgetText(dialog, table_object + "_id") # Check if we already have data with selected object_id sql = ("SELECT * " " FROM " + self.schema_name + "." + str(table_object) + "" " WHERE " + str(field_object_id) + " = '" + str(object_id) + "'") row = self.controller.get_row(sql, log_info=False) # If object_id not found: Clear data if not row: self.reset_widgets(dialog, table_object) if table_object == 'element': self.set_combo(dialog, 'state', 'value_state', 'state_vdefault', field_name='name') self.set_combo(dialog, 'expl_id', 'exploitation', 'exploitation_vdefault', field_id='expl_id',field_name='name') self.set_calendars(dialog, 'builtdate', 'config_param_user', 'value', 'builtdate_vdefault') self.set_combo(dialog, 'workcat_id', 'cat_work', 'workcat_vdefault', field_id='id', field_name='id') if hasattr(self, 'single_tool_mode'): # some tools can work differently if standalone or integrated in # another tool if self.single_tool_mode: self.remove_selection(True) else: self.remove_selection(True) self.reset_model(dialog, table_object, "arc") self.reset_model(dialog, table_object, "node") self.reset_model(dialog, table_object, "connec") self.reset_model(dialog, table_object, "element") if self.project_type == 'ud': self.reset_model(dialog, table_object, "gully") return # Fill input widgets with data of the @row self.fill_widgets(dialog, table_object, row) # Check related 'arcs' self.get_records_geom_type(dialog, table_object, "arc") # Check related 'nodes' self.get_records_geom_type(dialog, table_object, "node") # Check related 'connecs' self.get_records_geom_type(dialog, table_object, "connec") # Check related 'elements' self.get_records_geom_type(dialog, table_object, "element") # Check related 'gullys' if self.project_type == 'ud': self.get_records_geom_type(dialog, table_object, "gully")
def save_tab_add_info(self): """ Save tab from tab 'Add. info' """ if self.epa_type == "TANK": vmax = utils_giswater.getWidgetText("man_tank_vmax", False) area = utils_giswater.getWidgetText("man_tank_area", False) sql = " UPDATE " + self.schema_name + ".man_tank SET" sql += " vmax = " + str(vmax) + ", area = " + str(area) sql += " WHERE node_id = '" + self.id + "';" self.dao.execute_sql(sql) total = self.dao.get_rowcount() # Perform an INSERT if any record has been updated # TODO: If trigger was working correctly this wouldn't be necessary! if total == 0: sql = "INSERT INTO " + self.schema_name + ".man_tank (node_id, vmax, area) VALUES" sql += " ('" + self.id + "', " + str(vmax) + ", " + str(area) + ");" self.dao.execute_sql(sql)
def filter_elementcat_id(self): """ Filter QComboBox @elementcat_id according QComboBox @elementtype_id """ sql = ("SELECT DISTINCT(id) FROM " + self.schema_name + ".cat_element" " WHERE elementtype_id = '" + utils_giswater.getWidgetText(self.dlg_add_element, "element_type") + "'" " ORDER BY id") rows = self.controller.get_rows(sql) utils_giswater.fillComboBox(self.dlg_add_element, "elementcat_id", rows, False)
def fill_arc_type(self): ''' Define and execute query to populate combo 'cat_arctype_id' ''' cat_arctype_id = utils_giswater.getWidgetText("cat_arctype_id", False) sql = "SELECT id, man_table, epa_table FROM " + self.schema_name + ".arc_type" sql += " WHERE epa_default = '" + self.epa_type + "' ORDER BY id" rows = self.dao.get_rows(sql) utils_giswater.fillComboBox("cat_arctype_id", rows) utils_giswater.setWidgetText("cat_arctype_id", cat_arctype_id)
def fill_arc_type(self): ''' Define and execute query to populate combo 'cat_arctype_id' ''' cat_arctype_id = utils_giswater.getWidgetText("cat_arctype_id", False) sql = "SELECT id, man_table, epa_table FROM "+self.schema_name+".arc_type" sql+= " WHERE epa_default = '"+self.epa_type+"' ORDER BY id" rows = self.dao.get_rows(sql) utils_giswater.fillComboBox("cat_arctype_id", rows) utils_giswater.setWidgetText("cat_arctype_id", cat_arctype_id)
def save_tab_add_info(self): ''' Save tab from tab 'Add. info' ''' if self.epa_type == 'TANK': vmax = utils_giswater.getWidgetText("man_tank_vmax", False) area = utils_giswater.getWidgetText("man_tank_area", False) sql= " UPDATE "+self.schema_name+".man_tank SET" sql+= " vmax = "+str(vmax)+ ", area = "+str(area) sql+= " WHERE node_id = '"+self.id+"';" self.dao.execute_sql(sql) total = self.dao.get_rowcount() # Perform an INSERT if any record has been updated # TODO: If trigger was working correctly this wouldn't be necessary! if total == 0: sql = "INSERT INTO "+self.schema_name+".man_tank (node_id, vmax, area) VALUES" sql+= " ('"+self.id+"', "+str(vmax)+ ", "+str(area)+");" self.dao.execute_sql(sql)
def init_config(): feature_dialog.dialog.findChild(QComboBox, "connecat_id").setVisible(False) connecat_id = utils_giswater.getWidgetText("connecat_id", False) # TODO: Define slots feature_dialog.dialog.findChild(QPushButton, "btn_accept").clicked.connect(feature_dialog.save) feature_dialog.dialog.findChild(QPushButton, "btn_close").clicked.connect(feature_dialog.close)
def change_arc_type(self): ''' Define and execute query to populate combo 'arccat_id_dummy' ''' cat_arctype_id = utils_giswater.getWidgetText("cat_arctype_id", True) sql = "SELECT id FROM " + self.schema_name + ".cat_arc" sql += " WHERE arctype_id = " + cat_arctype_id + " ORDER BY id" rows = self.dao.get_rows(sql) utils_giswater.fillComboBox("arccat_id_dummy", rows, False) # Select first item by default self.change_arc_cat()
def change_arc_type(self): ''' Define and execute query to populate combo 'arccat_id_dummy' ''' cat_arctype_id = utils_giswater.getWidgetText("cat_arctype_id", True) sql = "SELECT id FROM "+self.schema_name+".cat_arc" sql+= " WHERE arctype_id = "+cat_arctype_id+" ORDER BY id" rows = self.dao.get_rows(sql) utils_giswater.fillComboBox("arccat_id_dummy", rows, False) # Select first item by default self.change_arc_cat()
def compare_depth(self, widget_ymax, show_message): widget_ymax.setStyleSheet("border: 1px solid gray") node_id = utils_giswater.getWidgetText(self.dialog, 'node_id') ymax = utils_giswater.getWidgetText(self.dialog, widget_ymax) if ymax is None: return bad_alert = False sql = ("SELECT * from " + self.schema_name + ".v_ui_node_x_connection_upstream " " WHERE node_id = '" + str(node_id) + "'") rows = self.controller.get_rows(sql, log_sql=False) arcs_list = "" if len(rows) > 0: arcs_list += "Upstream: " for row in rows: if row['upstream_depth'] is not None: if float(ymax) < float(row['upstream_depth']): widget_ymax.setStyleSheet("border: 1px solid red") arcs_list += str((row['feature_id'] + ", ")) bad_alert = True sql = ("SELECT * from " + self.schema_name + ".v_ui_node_x_connection_downstream " " WHERE node_id = '" + str(node_id) + "'") rows = self.controller.get_rows(sql, log_sql=False) if len(rows) > 0: arcs_list += "Downstream: " for row in rows: if row['downstream_depth'] is not None: if float(ymax) < float(row['downstream_depth']): widget_ymax.setStyleSheet("border: 1px solid red") arcs_list += str((row['feature_id'] + ", ")) bad_alert = True if len(arcs_list) > 2: arcs_list = arcs_list[:-2] if show_message and bad_alert: msg = "The depth of this node is less than the arc/'s {}".format( arcs_list) # self.controller.show_info_box(text=msg, title="Info") msg_box = QMessageBox() msg_box.setIcon(3) msg_box.setWindowTitle("Warning") msg_box.setText(msg) msg_box.exec_()
def filter_by_id(self, table, widget_txt, tablename): id_ = utils_giswater.getWidgetText(self.dlg_min_edit, widget_txt) if id_ != 'null': expr = " id = '" + id_ + "'" # Refresh model with selected filter table.model().setFilter(expr) table.model().select() else: self.fill_table_mincut_management(self.tbl_mincut_edit, self.schema_name + "." + tablename)
def filter_by_state(self, table, widget, tablename): state = utils_giswater.getWidgetText(self.dlg_min_edit, widget) if state != 'null': expr_filter = " state = '" + str(state) + "'" # Refresh model with selected expr_filter table.model().setFilter(expr_filter) table.model().select() else: self.fill_table_mincut_management(self.tbl_mincut_edit, self.schema_name + "." + tablename)
def init_config_form(self): """ Custom form initial configuration """ # Define class variables self.field_id = "gully_id" self.id = utils_giswater.getWidgetText(self.field_id, False) self.filter = self.field_id + " = '" + str(self.id) + "'" self.gully_type = utils_giswater.getWidgetText("arccat_id", False) self.gratecat_id = utils_giswater.getWidgetText("gratecat_id", False) # Get widget controls self.tab_main = self.dialog.findChild(QTabWidget, "tab_main") self.tbl_element = self.dialog.findChild(QTableView, "tbl_element") self.tbl_document = self.dialog.findChild(QTableView, "tbl_document") self.tbl_event = self.dialog.findChild(QTableView, "tbl_event_gully") feature = self.feature layer = self.iface.activeLayer() # Toolbar actions action = self.dialog.findChild(QAction, "actionEnabled") action.setChecked(layer.isEditable()) self.dialog.findChild(QAction, "actionZoom").triggered.connect( partial(self.action_zoom_in, feature, self.canvas, layer)) self.dialog.findChild(QAction, "actionCentered").triggered.connect( partial(self.action_centered, feature, self.canvas, layer)) self.dialog.findChild(QAction, "actionEnabled").triggered.connect( partial(self.action_enabled, action, layer)) self.dialog.findChild(QAction, "actionZoomOut").triggered.connect( partial(self.action_zoom_out, feature, self.canvas, layer)) # self.dialog.findChild(QAction, "actionHelp").triggered.connect(partial(self.action_help, 'ud', 'gully')) self.dialog.findChild(QAction, "actionLink").triggered.connect( partial(self.check_link, True)) # TODO: Manage custom fields tab_custom_fields = 1 self.manage_custom_fields(tab_to_remove=tab_custom_fields) # Manage tab signal self.tab_element_loaded = False self.tab_document_loaded = False self.tab_om_loaded = False self.tab_main.currentChanged.connect(self.tab_activation)
def reload_qtable(self, dialog, geom_type, plan_om): """ Reload QtableView """ value = utils_giswater.getWidgetText(dialog, dialog.psector_id) sql = ("SELECT * FROM " + self.schema_name + "." + plan_om + "_psector_x_" + geom_type + "" " WHERE psector_id = '" + str(value) + "'") qtable = utils_giswater.getWidget(dialog, 'tbl_psector_x_' + geom_type) self.fill_table_by_query(qtable, sql) self.set_table_columns(dialog, qtable, plan_om + "_psector_x_"+geom_type) self.refresh_map_canvas()
def update_location_cmb(self): element_type = utils_giswater.getWidgetText(self.dlg_add_element, self.dlg_add_element.element_type) sql = ("SELECT location_type FROM " + self.schema_name + ".man_type_location" " WHERE feature_type = 'ELEMENT' " " AND (featurecat_id = '"+str(element_type)+"' OR featurecat_id is null)" " ORDER BY location_type") rows = self.controller.get_rows(sql, log_sql=True, commit=self.autocommit) utils_giswater.fillComboBox(self.dlg_add_element, "location_type", rows) if rows: utils_giswater.setCurrentIndex(self.dlg_add_element, "location_type", 0)
def workcat_filter_by_text(self, table, widget_txt): result_select = utils_giswater.getWidgetText(widget_txt) if result_select != 'null': expr = " feature_id LIKE '%" + result_select + "%'" # Refresh model with selected filter table.model().setFilter(expr) table.model().select() else: self.workcat_fill_table(self.workcat_id)
def network_zoom(self, network_code, network_geom_type): """ Zoom feature with the code set in 'network_code' of the layer set in 'network_geom_type' """ # Get selected code from combo element = utils_giswater.getWidgetText(network_code) if element == 'null': return # Split element. [0]: feature_id, [1]: cat_feature_id row = element.split(' ', 1) feature_id = str(row[0]) cat_feature_id = str(row[1]) # Get selected layer geom_type = utils_giswater.getWidgetText(network_geom_type).lower() if geom_type == "null": sql = ("SELECT feature_type FROM " + self.controller.schema_name + ".cat_feature" " WHERE id = '" + cat_feature_id + "'") row = self.controller.get_row(sql) if not row: return geom_type = row[0].lower() fieldname = geom_type + "_id" # Check if the expression is valid aux = fieldname + " = '" + feature_id + "'" expr = QgsExpression(aux) if expr.hasParserError(): message = expr.parserErrorString() + ": " + aux self.controller.show_warning(message) return for value in self.feature_cat.itervalues(): if value.type.lower() == geom_type: layer = self.controller.get_layer_by_layername(value.layername) if layer: it = layer.getFeatures(QgsFeatureRequest(expr)) ids = [i.id() for i in it] layer.selectByIds(ids) # If any feature found, zoom it and exit function if layer.selectedFeatureCount() > 0: self.zoom_to_selected_features(layer) return
def fill_filter3(self, wsoftware, geom_type): # Get values from filters mats = utils_giswater.getWidgetText(self.dlg_cat.matcat_id) filter2 = utils_giswater.getWidgetText(self.dlg_cat.filter2) # Set SQL query sql_where = "" if wsoftware == 'ws' and geom_type != 'connec': sql = "SELECT " + self.field3 sql += " FROM (SELECT DISTINCT(regexp_replace(trim(' nm' FROM " + self.field3 + "),'-','', 'g')) as x, " + self.field3 elif wsoftware == 'ws' and geom_type == 'connec': sql = "SELECT DISTINCT(TRIM(TRAILING ' ' from " + self.field3 + ")) as " + self.field3 else: sql = "SELECT DISTINCT(" + self.field3 + ")" sql += " FROM " + self.schema_name + ".cat_" + geom_type # Build SQL filter if wsoftware == 'ws' and self.node_type_text is not None: sql_where = " WHERE " + geom_type + "type_id = '" + self.node_type_text + "'" if mats != "null": if sql_where == "": sql_where = " WHERE" else: sql_where += " AND" sql_where += " matcat_id = '" + mats + "'" if filter2 != "null": if sql_where == "": sql_where = " WHERE" else: sql_where += " AND" sql_where += " " + self.field2 + " = '" + filter2 + "'" if wsoftware == 'ws' and geom_type != 'connec': sql += sql_where + " ORDER BY x) AS " + self.field3 else: sql += sql_where + " ORDER BY " + self.field3 rows = self.controller.get_rows(sql) utils_giswater.fillComboBox(self.dlg_cat.filter3, rows) self.fill_catalog_id(wsoftware, geom_type)
def filter_by_text(self, table, widget_txt, tablename): result_select = utils_giswater.getWidgetText(widget_txt) if result_select != 'null': expr = " name ILIKE '%" + result_select + "%'" # Refresh model with selected filter table.model().setFilter(expr) table.model().select() else: self.fill_table(table, tablename)
def workcat_filter_by_text(self, qtable, widget_txt, table_name, workcat_id): result_select = utils_giswater.getWidgetText(widget_txt) if result_select != 'null': expr = "workcat_id = '" + str(workcat_id) + "'" expr += "and feature_id ILIKE '%" + str(result_select) + "%'" else: expr = "workcat_id ILIKE '%" + str(workcat_id) + "%'" self.workcat_fill_table(qtable, table_name, expr=expr) self.set_table_columns(qtable, table_name)
def refresh_table(self, widget): """ Refresh qTableView 'selected_rows' """ widget.selectAll() selected_list = widget.selectionModel().selectedRows() widget.clearSelection() for i in range(0, len(selected_list)): row = selected_list[i].row() if str(widget.model().record(row).value('psector_id')) != utils_giswater.getWidgetText('psector_id'): widget.hideRow(i)
def reload_table_visit(self): feature_type = utils_giswater.get_item_data( self.dlg_lot, self.dlg_lot.cmb_visit_class, 2) object_id = utils_giswater.getWidgetText(self.dlg_lot, self.dlg_lot.txt_filter) visit_start = self.dlg_lot.date_event_from.date() visit_end = self.dlg_lot.date_event_to.date() # Get selected dates date_from = visit_start.toString('yyyyMMdd 00:00:00') date_to = visit_end.toString('yyyyMMdd 23:59:59') if date_from > date_to: message = "Selected date interval is not valid" self.controller.show_warning(message) return visit_class_id = utils_giswater.get_item_data( self.dlg_lot, self.dlg_lot.cmb_visit_class, 0) sql = ("SELECT visitclass_id, formname, tablename FROM " + self.schema_name + ".config_api_visit " " WHERE visitclass_id ='" + str(visit_class_id) + "'") row = self.controller.get_row(sql, log_sql=False) table_name = row['tablename'] if self.schema_name not in table_name: table_name = self.schema_name + "." + table_name # Create interval dates format_low = 'yyyy-MM-dd 00:00:00.000' format_high = 'yyyy-MM-dd 23:59:59.999' interval = "'{}'::timestamp AND '{}'::timestamp".format( visit_start.toString(format_low), visit_end.toString(format_high)) expr_filter = ("(startdate BETWEEN {0}) AND (enddate BETWEEN {0})". format(interval)) if object_id != 'null': expr_filter += " AND " + str( feature_type) + "_id::TEXT ILIKE '%" + str(object_id) + "%'" expr_filter += " AND " + str(feature_type) + "_id IN ('0', " for i in range(len(self.ids)): expr_filter += "'" + str(self.ids[i]) + "', " expr_filter = expr_filter[:-2] + ")" model = QSqlTableModel() model.setTable(table_name) model.setEditStrategy(QSqlTableModel.OnManualSubmit) model.setFilter(expr_filter) 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 self.dlg_lot.tbl_visit.setModel(model)
def insert_or_update_config_param_curuser(self, dialog, widget, parameter, tablename): """ Insert or update values in tables with current_user control """ sql = 'SELECT * FROM ' + self.schema_name + '.' + tablename sql += ' WHERE "cur_user" = current_user' rows = self.controller.get_rows(sql) exist_param = False if type(widget) != QDateEdit: if utils_giswater.getWidgetText(dialog, widget) != "": for row in rows: if row[1] == parameter: exist_param = True if exist_param: sql = "UPDATE " + self.schema_name + "." + tablename + " SET value=" if widget.objectName() != 'state_vdefault': sql += "'" + utils_giswater.getWidgetText(dialog, widget) + "' WHERE parameter='" + parameter + "'" else: sql += ("(SELECT id FROM " + self.schema_name + ".value_state" " WHERE name = '" + utils_giswater.getWidgetText(dialog, widget) + "')" " WHERE parameter = 'state_vdefault'") else: sql = "INSERT INTO " + self.schema_name + "." + tablename + "(parameter, value, cur_user)" if widget.objectName() != 'state_vdefault': sql += " VALUES ('" + parameter + "', '" + utils_giswater.getWidgetText(dialog, widget) + "', current_user)" else: sql += (" VALUES ('" + parameter + "'," " (SELECT id FROM " + self.schema_name + ".value_state" " WHERE name ='" + utils_giswater.getWidgetText(dialog, widget) + "'), current_user)") else: for row in rows: if row[1] == parameter: exist_param = True if exist_param: sql = "UPDATE " + self.schema_name + "." + tablename + " SET value=" _date = widget.dateTime().toString('yyyy-MM-dd') sql += "'" + str(_date) + "' WHERE parameter='" + parameter + "'" else: sql = "INSERT INTO " + self.schema_name + "." + tablename + "(parameter, value, cur_user)" _date = widget.dateTime().toString('yyyy-MM-dd') sql += " VALUES ('" + parameter + "', '" + _date + "', current_user)" self.controller.execute_sql(sql)
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 = 'www.giswater.org' else: url = 'www.giswater.org' webbrowser.open(url)
def fill_tab_custom_fields(self): """ Fill tab 'Custom fields' """ arc_type = self.dialog.findChild(QComboBox, 'arc_type') cat_feature_id = utils_giswater.getWidgetText(self.dialog, arc_type) if cat_feature_id.lower() == "null": msg = "In order to manage custom fields, that field has to be set" self.controller.show_info(msg, parameter="'arc_type'", duration=10) return False self.manage_custom_fields(cat_feature_id) return True
def __init__(self, dialog, layer, feature): """ Constructor class """ self.geom_type = "node" self.field_id = "node_id" self.id = utils_giswater.getWidgetText(self.field_id, False) super(ManNodeDialog, self).__init__(dialog, layer, feature) self.init_config_form() self.controller.manage_translation('ud_man_node', dialog) if dialog.parent(): dialog.parent().setFixedSize(625, 660)
def init_config(): # Manage visibility feature_dialog.dialog.findChild(QComboBox, "connecat_id").setVisible(False) feature_dialog.dialog.findChild(QComboBox, "cat_connectype_id").setVisible(False) # Manage 'connecat_id' connecat_id = utils_giswater.getWidgetText("connecat_id") feature_dialog.dialog.findChild(QComboBox, "connecat_id_dummy").activated.connect(feature_dialog.change_connec_cat) utils_giswater.setSelectedItem("connecat_id_dummy", connecat_id) utils_giswater.setSelectedItem("connecat_id", connecat_id) # Manage 'connec_type' cat_connectype_id = utils_giswater.getWidgetText("cat_connectype_id") utils_giswater.setSelectedItem("cat_connectype_id_dummy", cat_connectype_id) feature_dialog.dialog.findChild(QComboBox, "cat_connectype_id_dummy").activated.connect(feature_dialog.change_connec_type_id) feature_dialog.change_connec_type_id(-1) # Set button signals feature_dialog.dialog.findChild(QPushButton, "btn_accept").clicked.connect(feature_dialog.update_sum) feature_dialog.dialog.findChild(QPushButton, "btn_close").clicked.connect(feature_dialog.close)
def change_node_type_id(self, index): ''' Define and execute query to populate combo 'cat_nodetype_id' ''' node_type_id = utils_giswater.getWidgetText("node_type_dummy", False) if node_type_id: utils_giswater.setWidgetText("node_type", node_type_id) sql = "SELECT id FROM "+self.schema_name+".cat_node" sql+= " WHERE nodetype_id = '"+node_type_id+"' ORDER BY id" rows = self.dao.get_rows(sql) utils_giswater.fillComboBox("nodecat_id_dummy", rows, False) if index == -1: utils_giswater.setWidgetText("nodecat_id_dummy", self.nodecat_id) self.change_node_cat()
def mg_result_selector_accept(self): ''' Update current values to the table ''' # Get new values from widgets of type QComboBox rpt_selector_result_id = utils_giswater.getWidgetText("rpt_selector_result_id") rpt_selector_compare_id = utils_giswater.getWidgetText("rpt_selector_compare_id") # Delete previous values # Set new values to tables 'rpt_selector_result' and 'rpt_selector_compare' sql= "DELETE FROM "+self.schema_name+".rpt_selector_result" self.dao.execute_sql(sql) sql= "DELETE FROM "+self.schema_name+".rpt_selector_compare" self.dao.execute_sql(sql) sql= "INSERT INTO "+self.schema_name+".rpt_selector_result VALUES ('"+rpt_selector_result_id+"');" self.dao.execute_sql(sql) sql= "INSERT INTO "+self.schema_name+".rpt_selector_compare VALUES ('"+rpt_selector_compare_id+"');" self.dao.execute_sql(sql) # Show message to user message = "Values has been updated" self.controller.show_info(message, context_name='ui_message') self.close_dialog(self.dlg)
def mg_change_elem_type_get_value(self, index): #@UnusedVariable ''' Just select item to 'real' combo 'nodecat_id' (that is hidden) ''' # Get selected value from 1st combobox self.value_combo1 = utils_giswater.getWidgetText("node_type_type_new") # When value is selected, enabled 2nd combo box if self.value_combo1 != 'null': self.dlg.node_node_type_new.setEnabled(True) # Fill 2nd combo_box-custom node type sql = "SELECT DISTINCT(id) FROM "+self.schema_name+".node_type WHERE type='"+self.value_combo1+"'" rows = self.dao.get_rows(sql) utils_giswater.fillComboBox("node_node_type_new", rows)
def init_config(): feature_dialog.dialog.findChild(QComboBox, "arccat_id").setVisible(False) arccat_id = utils_giswater.getWidgetText("arccat_id", False) feature_dialog.change_arc_type() feature_dialog.dialog.findChild(QComboBox, "cat_arctype_id").activated.connect(feature_dialog.change_arc_type) feature_dialog.dialog.findChild(QComboBox, "arccat_id_dummy").activated.connect(feature_dialog.change_arc_cat) utils_giswater.setSelectedItem("arccat_id_dummy", arccat_id) utils_giswater.setSelectedItem("arccat_id", arccat_id) feature_dialog.dialog.findChild(QComboBox, "epa_type").activated.connect(feature_dialog.change_epa_type) feature_dialog.dialog.findChild(QPushButton, "btn_accept").clicked.connect(feature_dialog.save) feature_dialog.dialog.findChild(QPushButton, "btn_close").clicked.connect(feature_dialog.close)
def init_config(): # Manage visibility feature_dialog.dialog.findChild(QComboBox, "cat_arctype_id").setVisible(False) feature_dialog.dialog.findChild(QComboBox, "arccat_id").setVisible(False) # Manage 'arccat_id' nodecat_id = utils_giswater.getWidgetText("arccat_id") feature_dialog.dialog.findChild(QComboBox, "arccat_id_dummy").activated.connect(feature_dialog.change_arc_cat) utils_giswater.setSelectedItem("arcccat_id_dummy", nodecat_id) utils_giswater.setSelectedItem("nodecat_id", nodecat_id) # Manage 'cat_arctype_id' arc_type_id = utils_giswater.getWidgetText("cat_arctype_id") utils_giswater.setSelectedItem("cat_arctype_id_dummy", arc_type_id) feature_dialog.dialog.findChild(QComboBox, "cat_arctype_id_dummy").activated.connect(feature_dialog.change_arc_type_id) feature_dialog.change_arc_type_id(-1) # Set 'epa_type' and button signals feature_dialog.dialog.findChild(QComboBox, "epa_type").activated.connect(feature_dialog.change_epa_type) feature_dialog.dialog.findChild(QPushButton, "btn_accept").clicked.connect(feature_dialog.save) feature_dialog.dialog.findChild(QPushButton, "btn_close").clicked.connect(feature_dialog.close)
def change_arc_type_id(self, index): ''' Define and execute query to populate combo 'cat_arctype_id' ''' arc_type_id = utils_giswater.getWidgetText("cat_arctype_id", False) if arc_type_id: utils_giswater.setWidgetText("cat_arctype_id", arc_type_id) sql = "SELECT id FROM "+self.schema_name+".cat_arc" sql+= " WHERE arctype_id = '"+arc_type_id+"' ORDER BY id" rows = self.dao.get_rows(sql) utils_giswater.fillComboBox("arccat_id_dummy", rows, False) if index == -1: utils_giswater.setWidgetText("arccat_id_dummy", self.arccat_id) self.change_arc_cat()
def ed_add_file_accept(self): ''' Insert or update document. Add document to selected feature ''' # Get values from dialog doc_id = utils_giswater.getWidgetText("doc_id") doc_type = utils_giswater.getWidgetText("doc_type") tagcat_id = utils_giswater.getWidgetText("tagcat_id") observ = utils_giswater.getWidgetText("observ") path = utils_giswater.getWidgetText("path") # Check if this document already exists sql = "SELECT DISTINCT(id) FROM "+self.schema_name+".doc WHERE id = '"+doc_id+"'" row = self.dao.get_row(sql) if row: answer = self.controller.ask_question("Are you sure you want change the data?") if answer: sql = "UPDATE "+self.schema_name+".doc " sql+= " SET doc_type = '"+doc_type+"', tagcat_id= '"+tagcat_id+"',observ = '"+observ+"', path = '"+path+"'" sql+= " WHERE id = '"+doc_id+"'" self.dao.execute_sql(sql) else: self.close_dialog(self.dlg) else: sql = "INSERT INTO "+self.schema_name+".doc (id, doc_type, path, observ, tagcat_id) " sql+= " VALUES ('"+doc_id+"', '"+doc_type+"', '"+path+"', '"+observ+"', '"+tagcat_id+"')" status = self.controller.execute_sql(sql) if not status: message = "Error inserting element in table, you need to review data" self.controller.show_warning(message, context_name='ui_message') return # Add document to selected feature self.ed_add_to_feature("doc", doc_id) # Show message to user message = "Values has been updated" self.controller.show_info(message, context_name='ui_message') self.close_dialog()
def save_tab_analysis(self): ''' Save tab from tab 'Analysis' ''' #super(ArcDialog, self).save_tab_analysis() if self.epa_type == 'PIPE': values = [] sql = "UPDATE "+self.schema_name+"."+self.epa_table+" SET " for i in range(len(self.fields_pipe)): widget_name = self.epa_table+"_"+self.fields_pipe[i] value = utils_giswater.getWidgetText(widget_name, True) values.append(value) sql+= self.fields_pipe[i]+" = "+str(values[i])+", " sql = sql[:-2] sql+= " WHERE "+self.field_id+" = '"+self.id+"'" self.dao.execute_sql(sql)
def init_config_form(self): """ Custom form initial configuration """ # Define local variables context_name = "ud_arc" table_element = "v_ui_element_x_arc" table_document = "v_ui_doc_x_arc" # Define class variables self.field_id = "arc_id" self.id = utils_giswater.getWidgetText(self.field_id, False) self.filter = self.field_id + " = '" + str(self.id) + "'" self.tab_main = self.dialog.findChild(QTabWidget, "tab_main") self.tbl_element = self.dialog.findChild(QTableView, "tbl_element") self.tbl_document = self.dialog.findChild(QTableView, "tbl_document") # Manage tab visibility self.set_tabs_visibility() # Manage i18n self.translate_form(context_name) # Load data from related tables # self.load_data() # Set layer in editing mode self.layer.startEditing() # Fill the element table self.fill_table(self.tbl_element, self.schema_name + "." + table_element, self.filter) # Configuration of element table self.set_configuration(self.tbl_element, table_element) # Fill the tab Document self.fill_tbl_document(self.tbl_document, self.schema_name + "." + table_document, self.filter) # Configuration of document table self.set_configuration(self.tbl_document, table_document) # Set signals btn_element_delete = self.dialog.findChild(QPushButton, "btn_element_delete") btn_doc_delete = self.dialog.findChild(QPushButton, "btn_doc_delete") if btn_element_delete: btn_element_delete.clicked.connect(partial(self.delete_records, self.tbl_element, table_element)) if btn_doc_delete: btn_doc_delete.clicked.connect(partial(self.delete_records, self.tbl_document, table_document))
def ed_add_file_autocomplete(self): ''' Once we select 'element_id' using autocomplete, fill widgets with current values ''' self.dlg.doc_id.setCompleter(self.completer) doc_id = utils_giswater.getWidgetText("doc_id") # Get values from database sql = "SELECT doc_type, tagcat_id, observ, path" sql+= " FROM "+self.schema_name+".doc" sql+= " WHERE id = '"+doc_id+"'" row = self.dao.get_row(sql) # Fill widgets columns_length = self.dao.get_columns_length() for i in range(0, columns_length): column_name = self.dao.get_column_name(i) utils_giswater.setWidgetText(column_name, row[column_name])
def ed_add_el_autocomplete(self): ''' Once we select 'element_id' using autocomplete, fill widgets with current values ''' self.dlg.element_id.setCompleter(self.completer) element_id = utils_giswater.getWidgetText("element_id") # Get values from database sql = "SELECT elementcat_id, location_type, ownercat_id, state, workcat_id," sql+= " buildercat_id, annotation, observ, comment, link, verified, rotation" sql+= " FROM "+self.schema_name+".element" sql+= " WHERE element_id = '"+element_id+"'" row = self.dao.get_row(sql) # Fill widgets columns_length = self.dao.get_columns_length() for i in range(0, columns_length): column_name = self.dao.get_column_name(i) utils_giswater.setWidgetText(column_name, row[column_name])
def mg_change_elem_type_get_value_2(self, index): ''' Just select item to 'real' combo 'nodecat_id' (that is hidden) ''' if index == -1: return # Get selected value from 2nd combobox self.value_combo2 = utils_giswater.getWidgetText("node_node_type_new") # When value is selected, enabled 3rd combo box if self.value_combo2 != 'null': # Get selected value from 2nd combobox self.dlg.node_nodecat_id.setEnabled(True) # Fill 3rd combo_box-catalog_id sql = "SELECT DISTINCT(id)" sql+= " FROM "+self.schema_name+".cat_node" sql+= " WHERE nodetype_id='"+self.value_combo2+"'" rows = self.dao.get_rows(sql) utils_giswater.fillComboBox("node_nodecat_id", rows)
def mg_config_accept_table(self, tablename, columns): ''' Update values of selected 'tablename' with the content of 'columns' ''' if columns is not None: sql = "UPDATE "+self.schema_name+"."+tablename+" SET " for column_name in columns: if column_name != 'id': widget_type = utils_giswater.getWidgetType(column_name) if widget_type is QCheckBox: value = utils_giswater.isChecked(column_name) else: value = utils_giswater.getWidgetText(column_name) if value is None or value == 'null': sql+= column_name+" = null, " else: if type(value) is not bool: value = value.replace(",", ".") sql+= column_name+" = '"+str(value)+"', " sql = sql[:-2] self.dao.execute_sql(sql)
def init_config_connec(self): ''' Custom form initial configuration for 'Connec' ''' # Define class variables self.field_id = "connec_id" self.id = utils_giswater.getWidgetText(self.field_id, False) # Get widget controls self.tab_analysis = self.dialog.findChild(QTabWidget, "tab_analysis") self.tab_event = self.dialog.findChild(QTabWidget, "tab_event") self.tab_main = self.dialog.findChild(QTabWidget, "tab_main") # Manage tab visibility self.set_tabs_visibility() # Manage i18n self.translate_form('ws_connec') # Load data from related tables self.load_data() # Set layer in editing mode self.layer.startEditing()
def change_node_type_id(self, index): """ Define and execute query to populate combo 'cat_nodetype_id' """ node_type_id = utils_giswater.getWidgetText("node_type_dummy", False) if node_type_id: utils_giswater.setWidgetText("node_type", node_type_id) sql = "SELECT id FROM " + self.schema_name + ".cat_node" sql += " WHERE nodetype_id = '" + node_type_id + "' ORDER BY id" rows = self.dao.get_rows(sql) utils_giswater.fillComboBox("nodecat_id_dummy", rows, False) if index == -1: utils_giswater.setWidgetText("nodecat_id_dummy", self.nodecat_id) self.change_node_cat() if self.loaded: sql = "SELECT epa_default FROM " + self.schema_name + ".node_type" sql += " WHERE id = '" + node_type_id + "'" rows = self.dao.get_rows(sql) utils_giswater.setWidgetText("epa_type", rows[0][0]) utils_giswater.setSelectedItem("epa_type", rows[0][0]) self.change_epa_type(-1) else: self.loaded = True
def init_config_form(self): ''' Custom form initial configuration ''' # Define local variables context_name = "ws_connec" table_element = "v_ui_element_x_connec" table_document = "v_ui_doc_x_connec" table_hydrometer = "v_rtc_hydrometer" table_hydrometer_epanet = "v_edit_rtc_hydro_data_x_connec" # Define class variables self.field_id = "connec_id" self.id = utils_giswater.getWidgetText(self.field_id, False) self.filter = self.field_id+" = '"+str(self.id)+"'" self.connec_type = utils_giswater.getWidgetText("cat_connectype_id", False) self.connecat_id = utils_giswater.getWidgetText("connecat_id", False) # Get widget controls self.tab_analysis = self.dialog.findChild(QTabWidget, "tab_analysis") self.tab_event = self.dialog.findChild(QTabWidget, "tab_event") self.tab_event_2 = self.dialog.findChild(QTabWidget, "tab_event_2") self.tab_main = self.dialog.findChild(QTabWidget, "tab_main") self.tbl_info = self.dialog.findChild(QTableView, "tbl_info") self.tbl_document = self.dialog.findChild(QTableView, "tbl_connec") self.tbl_dae = self.dialog.findChild(QTableView, "tbl_dae") self.tbl_dae_2 = self.dialog.findChild(QTableView, "tbl_dae_2") # Manage tab visibility self.set_tabs_visibility() # Manage i18n self.translate_form(context_name) # Define and execute query to populate combo 'cat_connectype_id_dummy' self.fill_connec_type_id() # Load data from related tables self.load_data() # Set layer in editing mode self.layer.startEditing() # Fill the info table self.fill_table(self.tbl_info, self.schema_name+"."+table_element, self.filter) # Configuration of info table self.set_configuration(self.tbl_info, table_element) # Fill the tab Document self.fill_tbl_document(self.tbl_document, self.schema_name+"."+table_document, self.filter) # Configuration of table Document self.set_configuration(self.tbl_document, table_document) # Fill tab Hydrometer | feature self.fill_tbl_hydrometer(self.tbl_dae, self.schema_name+"."+table_hydrometer, self.filter) # Configuration of table Hydrometer | feature self.set_configuration(self.tbl_dae, table_hydrometer) # Fill tab Hydrometer | epanet self.fill_tbl_hydrometer_epanet(self.tbl_dae_2, self.schema_name+"."+table_hydrometer_epanet, self.filter) # Configuration of table Hydrometer | epanet self.set_configuration(self.tbl_dae_2, table_hydrometer_epanet) # Set signals self.dialog.findChild(QPushButton, "delete_row_info").clicked.connect(partial(self.delete_records, self.tbl_info, table_element)) self.dialog.findChild(QPushButton, "delete_row_doc").clicked.connect(partial(self.delete_records, self.tbl_document, table_document)) self.dialog.findChild(QPushButton, "btn_delete_hydrometer").clicked.connect(partial(self.delete_records_dae, self.tbl_dae, table_hydrometer)) self.dialog.findChild(QPushButton, "btn_add_hydrometer").clicked.connect(self.insert_records)
def change_arc_cat(self): ''' Just select item to 'real' combo 'arccat_id' (that is hidden) ''' arccat_id_dummy = utils_giswater.getWidgetText("arccat_id_dummy") utils_giswater.setWidgetText("arccat_id", arccat_id_dummy)
def change_node_cat(self): """ Just select item to 'real' combo 'nodecat_id' (that is hidden) """ nodecat_id_dummy = utils_giswater.getWidgetText("nodecat_id_dummy") utils_giswater.setWidgetText("nodecat_id", nodecat_id_dummy)
def ed_add_element_accept(self): # Get values from dialog element_id = utils_giswater.getWidgetText("element_id") elementcat_id = utils_giswater.getWidgetText("elementcat_id") state = utils_giswater.getWidgetText("state") annotation = utils_giswater.getWidgetText("annotation") observ = utils_giswater.getWidgetText("observ") comment = utils_giswater.getWidgetText("comment") location_type = utils_giswater.getWidgetText("location_type") workcat_id = utils_giswater.getWidgetText("workcat_id") buildercat_id = utils_giswater.getWidgetText("buildercat_id") ownercat_id = utils_giswater.getWidgetText("ownercat_id") rotation = utils_giswater.getWidgetText("rotation") link = utils_giswater.getWidgetText("link") verified = utils_giswater.getWidgetText("verified") # Check if we already have data with selected element_id sql = "SELECT DISTINCT(element_id) FROM "+self.schema_name+".element WHERE element_id = '"+element_id+"'" row = self.dao.get_row(sql) if row: answer = self.controller.ask_question("Are you sure you want change the data?") if answer: sql = "UPDATE "+self.schema_name+".element" sql+= " SET element_id = '"+element_id+"', elementcat_id= '"+elementcat_id+"',state = '"+state+"', location_type = '"+location_type+"'" sql+= ", workcat_id= '"+workcat_id+"',buildercat_id = '"+buildercat_id+"', ownercat_id = '"+ownercat_id+"'" sql+= ", rotation= '"+rotation+"',comment = '"+comment+"', annotation = '"+annotation+"', observ= '"+observ+"',link = '"+link+"', verified = '"+verified+"'" sql+= " WHERE element_id = '"+element_id+"'" self.dao.execute_sql(sql) else: self.close_dialog(self.dlg) else: sql = "INSERT INTO "+self.schema_name+".element (element_id, elementcat_id, state, location_type" sql+= ", workcat_id, buildercat_id, ownercat_id, rotation, comment, annotation, observ, link, verified) " sql+= " VALUES ('"+element_id+"', '"+elementcat_id+"', '"+state+"', '"+location_type+"', '" sql+= workcat_id+"', '"+buildercat_id+"', '"+ownercat_id+"', '"+rotation+"', '"+comment+"', '" sql+= annotation+"','"+observ+"','"+link+"','"+verified+"')" status = self.controller.execute_sql(sql) if not status: message = "Error inserting element in table, you need to review data" self.controller.show_warning(message, context_name='ui_message') return # Add document to selected feature self.ed_add_to_feature("element", element_id) # Show message to user message = "Values has been updated" self.controller.show_info(message, context_name='ui_message') self.close_dialog()