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)
