def select_config(self, tablename): """ Get data from table 'config' and fill widgets according to the name of the columns """ sql = "SELECT * FROM " + self.schema_name + "." + tablename row = self.dao.get_row(sql) if not row: self.controller.show_warning("Any data found in table " + tablename) return None # Iterate over all columns and populate its corresponding widget columns = [] for i in range(0, len(row)): column_name = self.dao.get_column_name(i) widget_type = utils_giswater.getWidgetType(column_name) if widget_type is QCheckBox: utils_giswater.setChecked(column_name, row[column_name]) elif widget_type is QDateEdit: utils_giswater.setCalendarDate(column_name, datetime.strptime(row[column_name], '%Y-%m-%d')) elif widget_type is QTimeEdit: timeparts = str(row[column_name]).split(':') if len(timeparts) < 3: timeparts.append("0") days = int(timeparts[0]) / 24 hours = int(timeparts[0]) % 24 minuts = int(timeparts[1]) seconds = int(timeparts[2]) time = QTime(hours, minuts, seconds) utils_giswater.setTimeEdit(column_name, time) utils_giswater.setText(column_name + "_day", days) else: utils_giswater.setWidgetText(column_name, row[column_name]) columns.append(column_name) return columns
def master_config_master(self): """ Button 99: Open a dialog showing data from table 'config_param_system' """ # Create the dialog and signals self.dlg = ConfigMaster() utils_giswater.setDialog(self.dlg) self.load_settings(self.dlg) self.dlg.btn_accept.pressed.connect(self.master_config_master_accept) self.dlg.btn_cancel.pressed.connect(partial(self.close_dialog, self.dlg)) self.dlg.rejected.connect(partial(self.save_settings, self.dlg)) # Get records from tables 'config' and 'config_param_system' and fill corresponding widgets self.select_config("config") self.select_config_param_system("config_param_system") self.dlg.om_path_url.clicked.connect(partial(self.open_web_browser, "om_visit_absolute_path")) self.dlg.om_path_doc.clicked.connect(partial(self.get_folder_dialog, "om_visit_absolute_path")) self.dlg.doc_path_url.clicked.connect(partial(self.open_web_browser, "doc_absolute_path")) self.dlg.doc_path_doc.clicked.connect(partial(self.get_folder_dialog, "doc_absolute_path")) if self.project_type == 'ws': self.dlg.tab_topology.removeTab(1) sql = "SELECT name FROM" + self.schema_name + ".plan_psector ORDER BY name" rows = self.dao.get_rows(sql) utils_giswater.fillComboBox("psector_vdefault", rows) sql = "SELECT parameter, value FROM " + self.schema_name + ".config_param_user" sql += " WHERE parameter = 'psector_vdefault'" row = self.dao.get_row(sql) if row: utils_giswater.setChecked("chk_psector_enabled", True) utils_giswater.setWidgetText(str(row[0]), str(row[1])) self.dlg.exec_()
def basic_hydrometer_state_selector(self): """ Button 51: Hydrometer selector """ # Create the dialog and signals self.dlg_hydro_state = Multirow_selector() self.load_settings(self.dlg_hydro_state) self.dlg_hydro_state.btn_ok.clicked.connect( partial(self.close_dialog, self.dlg_hydro_state)) self.dlg_hydro_state.rejected.connect( partial(self.close_dialog, self.dlg_hydro_state)) self.dlg_hydro_state.txt_name.setVisible(False) self.dlg_hydro_state.setWindowTitle("Hydrometer selector") utils_giswater.setWidgetText( self.dlg_hydro_state, self.dlg_hydro_state.lbl_unselected, self.controller.tr('Unselected hydrometers', context_name='labels')) utils_giswater.setWidgetText( self.dlg_hydro_state, self.dlg_hydro_state.lbl_selected, self.controller.tr('Selected hydrometers', context_name='labels')) tableleft = "ext_rtc_hydrometer_state" tableright = "selector_hydrometer" field_id_left = "id" field_id_right = "state_id" self.multi_row_selector(self.dlg_hydro_state, tableleft, tableright, field_id_left, field_id_right) # Open dialog self.open_dialog(self.dlg_hydro_state, maximize_button=False)
def fill_fields(self): """ Fill dates and combo cat_work """ sql = ( "SELECT value FROM " + self.controller.schema_name + ".config_param_user " " WHERE parameter = 'enddate_vdefault' and cur_user = current_user" ) row = self.controller.get_row(sql, log_info=False) if row: enddate = QDate.fromString(row[0], 'yyyy-MM-dd') else: enddate = QDate.currentDate() utils_giswater.setCalendarDate(self.dlg_work_end, "enddate", enddate) sql = ("SELECT id FROM " + self.controller.schema_name + ".cat_work") rows = self.controller.get_rows(sql) utils_giswater.fillComboBox(self.dlg_work_end, self.dlg_work_end.workcat_id_end, rows, allow_nulls=False) utils_giswater.set_autocompleter(self.dlg_work_end.workcat_id_end) sql = ( "SELECT value FROM " + self.controller.schema_name + ".config_param_user " " WHERE parameter = 'workcat_vdefault' and cur_user = current_user" ) row = self.controller.get_row(sql, log_info=False) if row: utils_giswater.setWidgetText(self.dlg_work_end, self.dlg_work_end.workcat_id_end, row[0])
def info_show_info(self): """ Button 36: Info show info, open giswater and visit web page """ # Create form self.dlg_info = InfoShowInfo() utils_giswater.setDialog(self.dlg_info) self.load_settings(self.dlg_info) # Get Plugin, Giswater, PostgreSQL and Postgis version postgresql_version = self.controller.get_postgresql_version() postgis_version = self.controller.get_postgis_version() plugin_version = self.get_plugin_version() (giswater_file_path, giswater_build_version) = self.get_giswater_jar() #@UnusedVariable message = ("Plugin version: " + str(plugin_version) + "\n" "Giswater version: " + str(giswater_build_version) + "\n" "PostgreSQL version: " + str(postgresql_version) + "\n" "Postgis version: " + str(postgis_version)) utils_giswater.setWidgetText(self.dlg_info.txt_info, message) # Set signals self.dlg_info.btn_open_giswater.clicked.connect(self.open_giswater) self.dlg_info.btn_open_web.clicked.connect(partial(self.open_web_browser, None)) self.dlg_info.btn_close.clicked.connect(partial(self.close_dialog, self.dlg_info)) # Open dialog self.open_dialog(self.dlg_info, maximize_button=False)
def ud_hydrology_selector(self): """ Dialog hydrology_selector.ui """ self.dlg_hydrology_selector = HydrologySelector() self.load_settings(self.dlg_hydrology_selector) self.dlg_hydrology_selector.btn_accept.clicked.connect(self.save_hydrology) self.dlg_hydrology_selector.hydrology.currentIndexChanged.connect(self.update_labels) self.dlg_hydrology_selector.txt_name.textChanged.connect(partial(self.filter_cbx_by_text, "cat_hydrology", self.dlg_hydrology_selector.txt_name, self.dlg_hydrology_selector.hydrology)) sql = ("SELECT DISTINCT(name), hydrology_id FROM " + self.schema_name + ".cat_hydrology ORDER BY name") rows = self.controller.get_rows(sql) if not rows: message = "Any data found in table" self.controller.show_warning(message, parameter='cat_hydrology') return False utils_giswater.set_item_data(self.dlg_hydrology_selector.hydrology, rows) sql = ("SELECT DISTINCT(t1.name) FROM " + self.schema_name + ".cat_hydrology AS t1" " INNER JOIN " + self.schema_name + ".inp_selector_hydrology AS t2 ON t1.hydrology_id = t2.hydrology_id " " WHERE t2.cur_user = current_user") row = self.controller.get_row(sql) if row: utils_giswater.setWidgetText(self.dlg_hydrology_selector, self.dlg_hydrology_selector.hydrology, row[0]) else: utils_giswater.setWidgetText(self.dlg_hydrology_selector, self.dlg_hydrology_selector.hydrology, 0) self.update_labels() self.dlg_hydrology_selector.setWindowFlags(Qt.WindowStaysOnTopHint) self.dlg_hydrology_selector.exec_()
def open_dlg_rapports(self, previous_dialog): default_file_name = utils_giswater.getWidgetText(previous_dialog.name) self.dlg_psector_rapport = Psector_rapport() utils_giswater.setDialog(self.dlg_psector_rapport) self.load_settings(self.dlg_psector_rapport) utils_giswater.setWidgetText('txt_composer_path', default_file_name + " comp.pdf") utils_giswater.setWidgetText('txt_csv_detail_path', default_file_name + " detail.csv") utils_giswater.setWidgetText('txt_csv_path', default_file_name + ".csv") self.dlg_psector_rapport.btn_cancel.pressed.connect(partial(self.set_prev_dialog, self.dlg_psector_rapport, previous_dialog)) self.dlg_psector_rapport.btn_ok.pressed.connect(partial(self.generate_rapports, previous_dialog, self.dlg_psector_rapport)) self.dlg_psector_rapport.btn_path.pressed.connect(partial(self.get_folder_dialog, self.dlg_psector_rapport.txt_path)) utils_giswater.setWidgetText(self.dlg_psector_rapport.txt_path, self.controller.plugin_settings_value('psector_rapport_path')) utils_giswater.setChecked(self.dlg_psector_rapport.chk_composer, bool(self.controller.plugin_settings_value('psector_rapport_chk_composer'))) utils_giswater.setChecked(self.dlg_psector_rapport.chk_csv_detail, self.controller.plugin_settings_value('psector_rapport_chk_csv_detail')) utils_giswater.setChecked(self.dlg_psector_rapport.chk_csv, self.controller.plugin_settings_value('psector_rapport_chk_csv')) if utils_giswater.getWidgetText(self.dlg_psector_rapport.txt_path) == 'null': if 'nt' in sys.builtin_module_names: plugin_dir = os.path.expanduser("~\Documents") else: plugin_dir = os.path.expanduser("~") utils_giswater.setWidgetText(self.dlg_psector_rapport.txt_path, plugin_dir) # Open dialog self.open_dialog(self.dlg_psector_rapport, maximize_button=False)
def go2epa_result_selector(self): """ Button 29: Epa result selector """ # Create the dialog and signals self.dlg_go2epa_result = EpaResultCompareSelector() self.load_settings(self.dlg_go2epa_result) self.dlg_go2epa_result.btn_accept.clicked.connect(self.result_selector_accept) self.dlg_go2epa_result.btn_cancel.clicked.connect(partial(self.close_dialog, self.dlg_go2epa_result)) self.dlg_go2epa_result.rejected.connect(partial(self.close_dialog, self.dlg_go2epa_result)) # Set values from widgets of type QComboBox sql = "SELECT DISTINCT(result_id) FROM " + self.schema_name + ".v_ui_rpt_cat_result ORDER BY result_id" rows = self.controller.get_rows(sql) utils_giswater.fillComboBox(self.dlg_go2epa_result, self.dlg_go2epa_result.rpt_selector_result_id, rows) utils_giswater.fillComboBox(self.dlg_go2epa_result, self.dlg_go2epa_result.rpt_selector_compare_id, rows) # Get current data from tables 'rpt_selector_result' and 'rpt_selector_compare' sql = "SELECT result_id FROM " + self.schema_name + ".rpt_selector_result" row = self.controller.get_row(sql) if row: utils_giswater.setWidgetText(self.dlg_go2epa_result, self.dlg_go2epa_result.rpt_selector_result_id, row["result_id"]) sql = "SELECT result_id FROM " + self.schema_name + ".rpt_selector_compare" row = self.controller.get_row(sql) if row: utils_giswater.setWidgetText(self.dlg_go2epa_result, self.dlg_go2epa_result.rpt_selector_compare_id, row["result_id"]) # Open the dialog self.dlg_go2epa_result.setWindowFlags(Qt.WindowStaysOnTopHint) self.dlg_go2epa_result.exec_()
def go2epa_result_selector(self): """ Button 25. Result selector """ # Create the dialog and signals self.dlg = ResultCompareSelector() utils_giswater.setDialog(self.dlg) self.dlg.btn_accept.pressed.connect(self.result_selector_accept) self.dlg.btn_cancel.pressed.connect(self.close_dialog) # Set values from widgets of type QComboBox sql = "SELECT DISTINCT(result_id) FROM " + self.schema_name + ".rpt_cat_result ORDER BY result_id" rows = self.dao.get_rows(sql) utils_giswater.fillComboBox("rpt_selector_result_id", rows) utils_giswater.fillComboBox("rpt_selector_compare_id", rows) # Get current data from tables 'rpt_selector_result' and 'rpt_selector_compare' sql = "SELECT result_id FROM " + self.schema_name + ".rpt_selector_result" row = self.dao.get_row(sql) if row: utils_giswater.setWidgetText("rpt_selector_result_id", row["result_id"]) sql = "SELECT result_id FROM " + self.schema_name + ".rpt_selector_compare" row = self.dao.get_row(sql) if row: utils_giswater.setWidgetText("rpt_selector_compare_id", row["result_id"]) # Open the dialog self.dlg.exec_()
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 mg_result_selector(self): ''' Button 25. Result selector ''' # Create the dialog and signals self.dlg = ResultCompareSelector() utils_giswater.setDialog(self.dlg) self.dlg.btn_accept.pressed.connect(self.mg_result_selector_accept) self.dlg.btn_cancel.pressed.connect(self.close_dialog) # Set values from widgets of type QComboBox sql = "SELECT DISTINCT(result_id) FROM "+self.schema_name+".rpt_cat_result ORDER BY result_id" rows = self.dao.get_rows(sql) utils_giswater.fillComboBox("rpt_selector_result_id", rows) utils_giswater.fillComboBox("rpt_selector_compare_id", rows) # Get current data from tables 'rpt_selector_result' and 'rpt_selector_compare' sql = "SELECT result_id FROM "+self.schema_name+".rpt_selector_result" row = self.dao.get_row(sql) if row: utils_giswater.setWidgetText("rpt_selector_result_id", row["result_id"]) sql = "SELECT result_id FROM "+self.schema_name+".rpt_selector_compare" row = self.dao.get_row(sql) if row: utils_giswater.setWidgetText("rpt_selector_compare_id", row["result_id"]) # Open the dialog self.dlg.exec_()
def action_rotation_canvas_clicked(self, point, btn): if btn == Qt.RightButton: self.disable_rotation() return viewname = self.controller.get_layer_source_table_name(self.layer) sql = ("SELECT ST_X(the_geom), ST_Y(the_geom)" " FROM " + self.schema_name + "." + viewname + "" " WHERE node_id = '" + self.id + "'") row = self.controller.get_row(sql) if row: existing_point_x = row[0] existing_point_y = row[1] sql = ("UPDATE " + self.schema_name + ".node" " SET hemisphere = (SELECT degrees(ST_Azimuth(ST_Point(" + str(existing_point_x) + ", " + str(existing_point_y) + "), " " ST_Point(" + str(point.x()) + ", " + str(point.y()) + "))))" " WHERE node_id = '" + str(self.id) + "'") status = self.controller.execute_sql(sql) if not status: self.disable_rotation() return sql = ("SELECT degrees(ST_Azimuth(ST_Point(" + str(existing_point_x) + ", " + str(existing_point_y) + ")," " ST_Point( " + str(point.x()) + ", " + str(point.y()) + ")))") row = self.controller.get_row(sql) if row: utils_giswater.setWidgetText("hemisphere", str(row[0])) message = "Hemisphere of the node has been updated. Value is" self.controller.show_info(message, parameter=str(row[0])) self.disable_rotation()
def master_estimate_result_selector(self): """ Button 49: Estimate result selector """ # Create dialog self.dlg = EstimateResultSelector() utils_giswater.setDialog(self.dlg) self.load_settings(self.dlg) # Populate combo self.populate_combo(self.dlg.rpt_selector_result_id, 'plan_result_selector') # Set current value table_name = "om_result_cat" sql = ( "SELECT name FROM " + self.schema_name + "." + table_name + " " " WHERE cur_user = current_user AND result_type = 1 AND result_id = (SELECT result_id FROM " + self.schema_name + ".plan_result_selector)") row = self.controller.get_row(sql) if row: utils_giswater.setWidgetText(self.dlg.rpt_selector_result_id, str(row[0])) # Set signals self.dlg.btn_accept.clicked.connect( partial(self.master_estimate_result_selector_accept)) self.dlg.btn_cancel.clicked.connect(self.close_dialog) # Manage i18n of the form and open it self.controller.translate_form(self.dlg, 'estimate_result_selector') self.open_dialog(self.dlg, dlg_name="plan_estimate_result_selector", maximize_button=False)
def open_selected_object(self, widget, table_object): """ 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() # Get object_id from selected row field_object_id = "id" widget_id = table_object + "_id" if table_object == "element": field_object_id = table_object + "_id" if table_object == "om_visit": widget_id = "visit_id" selected_object_id = widget.model().record(row).value(field_object_id) # Close this dialog and open selected object self.dlg_man.close() # set previous dialog if hasattr(self, 'previous_dialog'): utils_giswater.setDialog(self.previous_dialog) if table_object == "doc": self.manage_document() utils_giswater.setWidgetText(widget_id, selected_object_id) elif table_object == "element": self.manage_element(new_element_id=False) utils_giswater.setWidgetText(widget_id, selected_object_id) elif table_object == "om_visit": self.manage_visit(visit_id=selected_object_id)
def get_coordinates(self, point, btn): #@UnusedVariable layer_name = self.iface.activeLayer().name() table = "v_edit_man_" + str(layer_name.lower()) sql = "SELECT ST_X(the_geom), ST_Y(the_geom)" sql += " FROM " + self.schema_name + "." + table sql += " WHERE node_id = '" + self.id + "'" row = self.controller.get_row(sql) if row: existing_point_x = row[0] existing_point_y = row[1] sql = "UPDATE " + self.schema_name + ".node" sql += " SET hemisphere = (SELECT degrees(ST_Azimuth(ST_Point(" + str( existing_point_x) + ", " + str(existing_point_y) + "), " sql += " ST_Point(" + str(point.x()) + ", " + str(point.y()) + "))))" sql += " WHERE node_id = '" + str(self.id) + "'" status = self.controller.execute_sql(sql) if status: message = "Hemisphere is updated for node " + str(self.id) self.controller.show_info(message) sql = "(SELECT degrees(ST_Azimuth(ST_Point(" + str( existing_point_x) + ", " + str(existing_point_y) + ")," sql += " ST_Point( " + str(point.x()) + ", " + str(point.y()) + "))))" row = self.controller.get_row(sql) if row: utils_giswater.setWidgetText( str(layer_name.lower()) + "_hemisphere", str(row[0]))
def set_values(self, lot_id): sql = ("SELECT * FROM " + self.schema_name + ".om_visit_lot " " WHERE id ='" + str(lot_id) + "'") lot = self.controller.get_row(sql, log_sql=False) if lot is not None: utils_giswater.setWidgetText(self.dlg_lot, 'txt_idval', lot['idval']) utils_giswater.setCalendarDate(self.dlg_lot, 'startdate', lot['startdate']) utils_giswater.setCalendarDate(self.dlg_lot, 'enddate', lot['enddate']) utils_giswater.set_combo_itemData(self.dlg_lot.cmb_visit_class, lot['visitclass_id'], 0) utils_giswater.set_combo_itemData(self.dlg_lot.cmb_assigned_to, lot['team_id'], 0) utils_giswater.setWidgetText(self.dlg_lot, 'descript', lot['descript']) utils_giswater.set_combo_itemData(self.dlg_lot.cmb_status, lot['status'], 0) self.controller.log_info(str(lot['status'])) if lot['status'] not in (0, None): self.dlg_lot.cmb_status.setEnabled(False) utils_giswater.set_combo_itemData(self.dlg_lot.feature_type, lot['feature_type'], 0) feature_type = utils_giswater.get_item_data(self.dlg_lot, self.dlg_lot.feature_type, 1).lower() table_name = "v_edit_" + str(feature_type) self.set_headers(self.tbl_relation) self.set_table_columns(self.dlg_lot, self.dlg_lot.tbl_relation, table_name)
def fill_fields(self): """ Fill combo boxes of the form """ # Visit tab # Set current date and time current_date = QDate.currentDate() self.dlg_lot.startdate.setDate(current_date) self.dlg_lot.enddate.setDate(current_date) # Set current user sql = "SELECT current_user" row = self.controller.get_row(sql, commit=self.autocommit) utils_giswater.setWidgetText(self.dlg_lot, self.user_name, row[0]) # Fill ComboBox cmb_visit_class sql = ("SELECT id, idval, feature_type" " FROM " + self.schema_name + ".om_visit_class " " WHERE ismultifeature is False" " ORDER BY idval") visitclass_ids = self.controller.get_rows(sql, commit=self.autocommit) if visitclass_ids: utils_giswater.set_item_data(self.dlg_lot.cmb_visit_class, visitclass_ids, 1) # Fill ComboBox cmb_assigned_to sql = ("SELECT id, idval" " FROM " + self.schema_name + ".cat_team " " WHERE active is True " " ORDER BY idval") users = self.controller.get_rows(sql, commit=self.autocommit) if users: utils_giswater.set_item_data(self.dlg_lot.cmb_assigned_to, users, 1) # TODO fill combo with correct table # Fill ComboBox cmb_status sql = ("SELECT id, idval" " FROM " + self.schema_name + ".om_visit_class " " ORDER BY idval") status = self.controller.get_rows(sql, commit=self.autocommit) status = [(0, 'PLANIFICAT'), (1, 'EXITOS'), (2, 'FAIL'), (3, 'VALIDAT')] if status: utils_giswater.set_item_data(self.dlg_lot.cmb_status, status, 1, sort_combo=False) # Relations tab # fill feature_type sql = ("SELECT id, id" " FROM " + self.schema_name + ".sys_feature_type" " WHERE net_category = 1" " ORDER BY id") feature_type = self.controller.get_rows(sql, log_sql=False, commit=self.autocommit) if feature_type: utils_giswater.set_item_data(self.dlg_lot.feature_type, feature_type, 1)
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 snapping(self, layer_view, tablename, table_view, elem_type): # Create the appropriate map tool and connect the gotPoint() signal map_canvas = self.iface.mapCanvas() self.emit_point = QgsMapToolEmitPoint(map_canvas) map_canvas.setMapTool(self.emit_point) utils_giswater.setWidgetText("btn_add_arc_plan", "Editing") utils_giswater.setWidgetText("btn_add_node_plan", "Editing") self.emit_point.canvasClicked.connect(partial(self.click_button_add, layer_view, tablename, table_view, elem_type))
def fill_connec_type_id(self): ''' Define and execute query to populate combo 'cat_connectype_id_dummy' ''' sql = "SELECT connec_type.id" sql+= " FROM "+self.schema_name+".connec_type INNER JOIN "+self.schema_name+".cat_connec ON connec_type.id = cat_connec.type" sql+= " GROUP BY connec_type.id ORDER BY connec_type.id" rows = self.dao.get_rows(sql) utils_giswater.fillComboBox("cat_connectype_id_dummy", rows, False) utils_giswater.setWidgetText("cat_connectype_id_dummy", self.connec_type)
def set_combo(self, dialog, widget, table_name, parameter, field_id='id', field_name='id'): """ Executes query and set combo box """ sql = ("SELECT t1." + field_name + " FROM " + self.schema_name + "." + table_name + " as t1" " INNER JOIN " + self.schema_name + ".config_param_user as t2 ON t1." + field_id + "::text = t2.value::text" " WHERE parameter = '" + parameter + "' AND cur_user = current_user") row = self.controller.get_row(sql) if row: utils_giswater.setWidgetText(dialog, widget, row[0])
def snapping_node(self, point, button): """ Get id of selected nodes (node1 and node2) """ if button == 2: self.dlg_destroyed() return map_point = self.canvas.getCoordinateTransform().transform(point) x = map_point.x() y = map_point.y() event_point = QPoint(x, y) # Snapping (retval, result) = self.snapper.snapToBackgroundLayers( event_point) # @UnusedVariable # That's the snapped point if result: # Check feature for snapped_point in result: if snapped_point.layer == self.layer_node: # Get the point snapp_feature = next( snapped_point.layer.getFeatures( QgsFeatureRequest().setFilterFid( snapped_point.snappedAtGeometry))) element_id = snapp_feature.attribute('node_id') message = "Selected node" if self.node1 is None: self.node1 = str(element_id) self.controller.show_message(message, message_level=0, duration=1, parameter=self.node1) elif self.node1 != str(element_id): self.node2 = str(element_id) self.controller.show_message(message, message_level=0, duration=1, parameter=self.node2) if self.node1 is not None and self.node2 is not None: self.iface.actionPan().trigger() self.iface.setActiveLayer(self.layer) self.iface.mapCanvas().scene().removeItem(self.vertex_marker) sql = ("SELECT " + self.schema_name + ".gw_fct_node_interpolate('" "" + str(self.last_point[0]) + "', '" + str(self.last_point[1]) + "', '" "" + str(self.node1) + "', '" + self.node2 + "')") row = self.controller.get_row(sql) if row: if 'elev' in row[0]: utils_giswater.setWidgetText(self.dialog, 'elev', row[0]['elev']) if 'top_elev' in row[0]: utils_giswater.setWidgetText(self.dialog, 'top_elev', row[0]['top_elev'])
def load_tab_add_info(self): ''' Load data from tab 'Add. info' ''' if self.epa_type == 'TANK': sql = "SELECT vmax, area" sql+= " FROM "+self.schema_name+".man_tank WHERE "+self.field_id+" = '"+self.id+"'" row = self.dao.get_row(sql) if row: utils_giswater.setWidgetText("man_tank_vmax", str(row[0])) utils_giswater.setWidgetText("man_tank_area", str(row[1]))
def set_label_current_psector(self): sql = ( "SELECT t1.name FROM " + self.schema_name + ".plan_psector AS t1 " " INNER JOIN " + self.schema_name + ".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('lbl_vdefault_psector', row[0])
def calc_pec_pem(self): if str(utils_giswater.getWidgetText('pec')) != 'null': pec = float(utils_giswater.getWidgetText('pec')) else: pec = 0 if str(utils_giswater.getWidgetText('pem')) != 'null': pem = float(utils_giswater.getWidgetText('pem')) else: pem = 0 res = pec - pem utils_giswater.setWidgetText('pec_pem', res)
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 calc_pca_pecvat(self): if str(utils_giswater.getWidgetText('pca')) != 'null': pca = float(utils_giswater.getWidgetText('pca')) else: pca = 0 if str(utils_giswater.getWidgetText('pec_vat')) != 'null': pec_vat = float(utils_giswater.getWidgetText('pec_vat')) else: pec_vat = 0 res = pca - pec_vat utils_giswater.setWidgetText('pca_pecvat', res)
def calc_pecvat_pec(self): if str(utils_giswater.getWidgetText('pec_vat')) != 'null': pec_vat = float(utils_giswater.getWidgetText('pec_vat')) else: pec_vat = 0 if str(utils_giswater.getWidgetText('pec')) != 'null': pec = float(utils_giswater.getWidgetText('pec')) else: pec = 0 res = pec_vat - pec utils_giswater.setWidgetText('pecvat_pem', res)
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 load_tab_analysis(self): ''' Load data from tab 'Analysis' ''' if self.epa_type == 'PIPE': self.fields_pipe = ['minorloss', 'status'] sql = "SELECT " for i in range(len(self.fields_pipe)): sql+= self.fields_pipe[i]+", " sql = sql[:-2] sql+= " FROM "+self.schema_name+"."+self.epa_table+" WHERE "+self.field_id+" = '"+self.id+"'" row = self.dao.get_row(sql) if row: for i in range(len(self.fields_pipe)): widget_name = self.epa_table+"_"+self.fields_pipe[i] utils_giswater.setWidgetText(widget_name, str(row[i]))
def load_tab_analysis(self): ''' Load data from tab 'Analysis' ''' if self.epa_type == 'PIPE': self.fields_pipe = ['minorloss', 'status'] sql = "SELECT " for i in range(len(self.fields_pipe)): sql += self.fields_pipe[i] + ", " sql = sql[:-2] sql += " FROM " + self.schema_name + "." + self.epa_table + " WHERE " + self.field_id + " = '" + self.id + "'" row = self.dao.get_row(sql) if row: for i in range(len(self.fields_pipe)): widget_name = self.epa_table + "_" + self.fields_pipe[i] utils_giswater.setWidgetText(widget_name, str(row[i]))
def fill_node_type_id(self): ''' Define and execute query to populate combo 'node_type_dummy' ''' # Get node_type.type from node_type.id sql = "SELECT type FROM "+self.schema_name+".node_type" sql+= " WHERE id = '"+self.node_type+"'" row = self.dao.get_row(sql) if row: node_type_type = row[0] sql = "SELECT id FROM "+self.schema_name+".node_type" sql+= " WHERE type = '"+node_type_type+"' ORDER BY id" sql = "SELECT node_type.id" sql+= " FROM "+self.schema_name+".node_type INNER JOIN "+self.schema_name+".cat_node ON node_type.id = cat_node.nodetype_id" sql+= " WHERE type = '"+node_type_type+"' GROUP BY node_type.id ORDER BY node_type.id" rows = self.dao.get_rows(sql) utils_giswater.fillComboBox("node_type_dummy", rows, False) utils_giswater.setWidgetText("node_type_dummy", self.node_type)
def fill_arc_type_id(self): ''' Define and execute query to populate combo 'node_type_dummy' ''' # Get node_type.type from node_type.id sql = "SELECT type FROM "+self.schema_name+".arc_type" if self.arc_type: sql+= " WHERE id = '"+self.arc_type+"'" row = self.dao.get_row(sql) if row: arc_type_type = row[0] sql = "SELECT arc_type.id" sql+= " FROM "+self.schema_name+".arc_type INNER JOIN "+self.schema_name+".cat_arc ON arc_type.id = cat_arc.arctype_id" sql+= " WHERE type = '"+arc_type_type+"' GROUP BY arc_type.id ORDER BY arc_type.id" rows = self.dao.get_rows(sql) utils_giswater.fillComboBox("cat_arctype_id_dummy", rows, False) utils_giswater.setWidgetText("cat_arctype_id_dummy", self.arc_type)
def edit_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_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 multi_rows_delete(self, dialog, 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 += str(id_) + ", " list_id = list_id + "'" + str(id_) + "', " inf_text = inf_text[:-2] list_id = list_id[:-2] message = "Are you sure you want to delete these records?" answer = self.controller.ask_question(message, "Delete records", inf_text) if answer: sql = ("DELETE FROM " + self.schema_name + "." + table_name + "" " WHERE " + column_id + " IN (" + list_id + ")") self.controller.execute_sql(sql) widget.model().select() sql = ( "SELECT value FROM " + self.schema_name + ".config_param_user " " WHERE parameter = 'psector_vdefault' AND cur_user = current_user" " AND value IN (" + list_id + ")") row = self.controller.get_row(sql) if row is not None: sql = ( "DELETE FROM " + self.schema_name + ".config_param_user " " WHERE parameter = 'psector_vdefault' AND cur_user = current_user" " AND value = '" + row[0] + "'") self.controller.execute_sql(sql) utils_giswater.setWidgetText(dialog, 'lbl_vdefault_psector', '')
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 load_tab_analysis(self): """ Load data from tab 'Analysis' """ if self.epa_type == "JUNCTION": # Load combo 'pattern_id' combo = self.epa_table + "_pattern_id" table_name = "inp_pattern" sql = "SELECT pattern_id FROM " + self.schema_name + "." + table_name + " ORDER BY pattern_id" rows = self.dao.get_rows(sql) utils_giswater.fillComboBox(combo, rows) self.fields_junction = ["demand", "pattern_id"] sql = "SELECT " for i in range(len(self.fields_junction)): sql += self.fields_junction[i] + ", " sql = sql[:-2] sql += " FROM " + self.schema_name + "." + self.epa_table + " WHERE node_id = '" + self.id + "'" row = self.dao.get_row(sql) if row: for i in range(len(self.fields_junction)): widget_name = self.epa_table + "_" + self.fields_junction[i] utils_giswater.setWidgetText(widget_name, str(row[i])) elif self.epa_type == "TANK": # Load combo 'curve_id' combo = self.epa_table + "_curve_id" table_name = "inp_curve_id" sql = "SELECT id FROM " + self.schema_name + ".inp_curve_id ORDER BY id" rows = self.dao.get_rows(sql) utils_giswater.fillComboBox(combo, rows) self.fields_tank = ["initlevel", "minlevel", "maxlevel", "diameter", "minvol", "curve_id"] sql = "SELECT " for i in range(len(self.fields_tank)): sql += self.fields_tank[i] + ", " sql = sql[:-2] sql += ( " FROM " + self.schema_name + "." + self.epa_table + " WHERE " + self.field_id + " = '" + self.id + "'" ) row = self.dao.get_row(sql) if row: for i in range(len(self.fields_tank)): widget_name = self.epa_table + "_" + self.fields_tank[i] utils_giswater.setWidgetText(widget_name, str(row[i]))
def mg_config_get_data(self, tablename): ''' Get data from selected table ''' sql = "SELECT *" sql+= " FROM "+self.schema_name+"."+tablename row = self.dao.get_row(sql) if not row: self.controller.show_warning("Any data found in table "+tablename) return None # Iterate over all columns and populate its corresponding widget columns = [] for i in range(0, len(row)): column_name = self.dao.get_column_name(i) widget_type = utils_giswater.getWidgetType(column_name) if widget_type is QCheckBox: utils_giswater.setChecked(column_name, row[column_name]) else: utils_giswater.setWidgetText(column_name, row[column_name]) columns.append(column_name) return columns
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 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 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)