def change_elem_type(self, feature):
# Create the dialog, fill node_type and define its signals
self.dlg_chg_node_type = NodeTypeChange()
load_settings(self.dlg_chg_node_type)
# Get nodetype_id from current node
node_type = ""
project_type = self.controller.get_project_type()
if project_type == 'ws':
node_type = feature.attribute('nodetype_id')
self.dlg_chg_node_type.node_node_type_new.currentIndexChanged.connect(partial(self.filter_catalog))
elif project_type == 'ud':
node_type = feature.attribute('node_type')
sql = "SELECT DISTINCT(id), id FROM cat_node ORDER BY id"
rows = self.controller.get_rows(sql)
qt_tools.set_item_data(self.dlg_chg_node_type.node_nodecat_id, rows, 1)
self.dlg_chg_node_type.node_node_type.setText(node_type)
self.dlg_chg_node_type.btn_catalog.clicked.connect(partial(self.open_catalog))
self.dlg_chg_node_type.btn_accept.clicked.connect(self.edit_change_elem_type_accept)
self.dlg_chg_node_type.btn_cancel.clicked.connect(partial(close_dialog, self.dlg_chg_node_type))
# Fill 1st combo boxes-new system node type
sql = ("SELECT DISTINCT(id) FROM cat_feature WHERE active is True "
"AND feature_type = 'NODE' ORDER BY id")
rows = self.controller.get_rows(sql)
qt_tools.fillComboBox(self.dlg_chg_node_type, "node_node_type_new", rows)
# Open dialog
open_dialog(self.dlg_chg_node_type, dlg_name='nodetype_change', maximize_button=False)
def populate_layer_combo(self):
geom_type = qt_tools.get_item_data(self.dlg_functions,
self.dlg_functions.cmb_geom_type, 0)
self.layers = []
self.layers = self.get_all_group_layers(geom_type)
layers = []
legend_layers = self.controller.get_layers()
for geom_type, layer in self.layers:
if layer in legend_layers:
elem = []
layer_name = self.controller.get_layer_source_table_name(layer)
elem.append(layer.name())
elem.append(layer_name)
elem.append(geom_type)
layers.append(elem)
if not layers:
elem = []
elem.append(f"There is no layer related to {geom_type}.")
elem.append(None)
elem.append(None)
layers.append(elem)
qt_tools.set_item_data(self.dlg_functions.cmb_layers,
layers,
sort_combo=False)
def fill_fields(self):
""" Fill dates and combos cat_work/state type end """
sql = 'SELECT id as id, name as idval FROM value_state_type WHERE id IS NOT NULL AND state = 0'
rows = self.controller.get_rows(sql)
qt_tools.set_item_data(self.dlg_work_end.cmb_statetype_end, rows, 1)
row = self.controller.get_config('statetype_end_vdefault')
if row:
qt_tools.set_combo_itemData(self.dlg_work_end.cmb_statetype_end,
row[0], 0)
row = self.controller.get_config('edit_enddate_vdefault')
if row:
enddate = self.manage_dates(row[0]).date()
self.dlg_work_end.enddate.setDate(enddate)
else:
enddate = QDate.currentDate()
qt_tools.setCalendarDate(self.dlg_work_end, "enddate", enddate)
sql = "SELECT id FROM cat_work"
rows = self.controller.get_rows(sql)
qt_tools.fillComboBox(self.dlg_work_end,
self.dlg_work_end.workcat_id_end,
rows,
allow_nulls=False)
qt_tools.set_autocompleter(self.dlg_work_end.workcat_id_end)
row = self.controller.get_config('edit_workcat_end_vdefault')
if row:
qt_tools.setWidgetText(self.dlg_work_end,
self.dlg_work_end.workcat_id_end, row[0])
def populate_combos(self, combo, field_id, fields, table_name, roles):
if roles is None:
return
sql = (f"SELECT DISTINCT({field_id}), {fields}"
f" FROM {table_name}"
f" JOIN sys_function ON function_name = functionname"
f" WHERE sys_role IN {roles} AND active is True ORDER BY orderby")
rows = self.controller.get_rows(sql, log_sql=True)
if not rows:
message = "You do not have permission to execute this application"
self.dlg_csv.lbl_info.setText(self.controller.tr(message))
self.dlg_csv.lbl_info.setStyleSheet("QLabel{color: red;}")
self.dlg_csv.cmb_import_type.setEnabled(False)
self.dlg_csv.txt_import.setEnabled(False)
self.dlg_csv.txt_file_csv.setEnabled(False)
self.dlg_csv.cmb_unicode_list.setEnabled(False)
self.dlg_csv.rb_comma.setEnabled(False)
self.dlg_csv.rb_semicolon.setEnabled(False)
self.dlg_csv.btn_file_csv.setEnabled(False)
self.dlg_csv.tbl_csv.setEnabled(False)
self.dlg_csv.btn_accept.setEnabled(False)
return
qt_tools.set_item_data(combo, rows, 1, True, True, 1)
self.update_info(self.dlg_csv)
def manage_duplicate_psector(self, psector_id=None):
# Create the dialog and signals
self.dlg_duplicate_psector = PsectorDuplicate()
self.load_settings(self.dlg_duplicate_psector)
# Populate combo duplicate psector
sql = "SELECT psector_id, name FROM plan_psector"
rows = self.controller.get_rows(sql)
qt_tools.set_item_data(self.dlg_duplicate_psector.duplicate_psector,
rows, 1)
# Set QComboBox with selected psector
qt_tools.set_combo_itemData(
self.dlg_duplicate_psector.duplicate_psector, str(psector_id), 0)
# Set listeners
self.dlg_duplicate_psector.btn_cancel.clicked.connect(
partial(self.close_dialog, self.dlg_duplicate_psector))
self.dlg_duplicate_psector.btn_accept.clicked.connect(
partial(self.duplicate_psector))
# Open dialog
self.open_dialog(self.dlg_duplicate_psector,
dlg_name='psector_duplicate')
def filter_state_type(self):
state = qt_tools.get_item_data(self.dlg_add_element, self.dlg_add_element.state, 0)
sql = (f"SELECT DISTINCT(id), name FROM value_state_type "
f"WHERE state = {state}")
rows = self.controller.get_rows(sql)
qt_tools.set_item_data(self.dlg_add_element.state_type, rows, 1)
def clicked_event(self):
# Create the dialog and signals
self.dlg_feature_delete = FeatureDelete()
load_settings(self.dlg_feature_delete)
# Populate combo feature type
sql = 'SELECT DISTINCT(feature_type) AS id, feature_type AS idval FROM cat_feature'
rows = self.controller.get_rows(sql)
qt_tools.set_item_data(self.dlg_feature_delete.feature_type, rows, 1)
# Set active layer
layer_name = 'v_edit_' + qt_tools.getWidgetText(
self.dlg_feature_delete,
self.dlg_feature_delete.feature_type).lower()
layer = self.controller.get_layer_by_tablename(layer_name)
self.iface.setActiveLayer(layer)
self.controller.set_layer_visible(layer)
# Disable button delete feature
self.dlg_feature_delete.btn_delete.setEnabled(False)
# Configure feature_id as typeahead
completer = QCompleter()
model = QStringListModel()
self.filter_typeahead(self.dlg_feature_delete.feature_id, completer,
model)
# Set listeners
self.dlg_feature_delete.feature_id.textChanged.connect(
partial(self.filter_typeahead, self.dlg_feature_delete.feature_id,
completer, model))
# Set button snapping
self.dlg_feature_delete.btn_snapping.clicked.connect(
partial(self.set_active_layer))
self.dlg_feature_delete.btn_snapping.clicked.connect(
partial(self.selection_init))
set_icon(self.dlg_feature_delete.btn_snapping, "137")
# Set listeners
self.dlg_feature_delete.btn_cancel.clicked.connect(
partial(close_dialog, self.dlg_feature_delete))
self.dlg_feature_delete.rejected.connect(
disconnect_signal_selection_changed)
self.dlg_feature_delete.rejected.connect(
partial(save_settings, self.dlg_feature_delete))
self.dlg_feature_delete.btn_relations.clicked.connect(
partial(self.show_feature_relation))
self.dlg_feature_delete.btn_delete.clicked.connect(
partial(self.delete_feature_relation))
self.dlg_feature_delete.feature_type.currentIndexChanged.connect(
partial(self.set_active_layer))
# Open dialog
open_dialog(self.dlg_feature_delete, dlg_name='feature_delete')
def filter_elementcat_id(self):
""" Filter QComboBox @elementcat_id according QComboBox @elementtype_id """
element_type = qt_tools.get_item_data(self.dlg_add_element, self.dlg_add_element.element_type, 1)
sql = (f"SELECT DISTINCT(id), id FROM cat_element"
f" WHERE elementtype_id = '{element_type}'"
f" ORDER BY id")
rows = self.controller.get_rows(sql, log_sql=True)
qt_tools.set_item_data(self.dlg_add_element.elementcat_id, rows, 1)
def populate_date_time(self, combo_date):
result_id = qt_tools.get_item_data(
self.dlg_go2epa_result,
self.dlg_go2epa_result.rpt_selector_result_id, 0)
sql = (f"SELECT DISTINCT(resultdate), resultdate FROM rpt_arc "
f"WHERE result_id = '{result_id}' "
f"ORDER BY resultdate")
rows = self.controller.get_rows(sql)
qt_tools.set_item_data(combo_date, rows)
def update_location_cmb(self):
element_type = qt_tools.getWidgetText(self.dlg_add_element, self.dlg_add_element.element_type)
sql = (f"SELECT location_type, location_type FROM man_type_location"
f" WHERE feature_type = 'ELEMENT' "
f" AND (featurecat_id = '{element_type}' OR featurecat_id is null)"
f" ORDER BY location_type")
rows = self.controller.get_rows(sql, log_sql=True)
qt_tools.set_item_data(self.dlg_add_element.location_type, rows, add_empty=True)
if rows:
qt_tools.set_combo_itemData(self.dlg_add_element.location_type, rows[0][0], 0)
def populate_cmb_type(self, feature_types):
feat_types = []
for item in feature_types:
elem = []
elem.append(item.upper())
elem.append(item.upper())
feat_types.append(elem)
if feat_types and len(feat_types) <= 1:
self.dlg_functions.cmb_geom_type.setVisible(False)
qt_tools.set_item_data(self.dlg_functions.cmb_geom_type, feat_types, 1)
def populate_cmb_language(self):
""" Populate combo with languages values """
self.dlg_qm.btn_translate.setEnabled(True)
host = qt_tools.getWidgetText(self.dlg_qm, self.dlg_qm.txt_host)
qt_tools.setWidgetText(self.dlg_qm, 'lbl_info', f'Connected to {host}')
sql = "SELECT user_language, py_language, xml_language, py_file FROM i18n.cat_language"
rows = self.get_rows(sql)
qt_tools.set_item_data(self.dlg_qm.cmb_language, rows, 0)
cur_user = self.controller.get_current_user()
language = self.controller.plugin_settings_value('qm_lang_language' +
cur_user)
qt_tools.set_combo_itemData(self.dlg_qm.cmb_language, language, 0)
def filter_cbx_by_text(self, tablename, widgettxt, widgetcbx):
sql = (f"SELECT DISTINCT(name), hydrology_id FROM {tablename}"
f" WHERE name LIKE '%{widgettxt.text()}%'"
f" ORDER BY name ")
rows = self.controller.get_rows(sql)
if not rows:
message = "Check the table 'cat_hydrology' "
self.controller.show_warning(message)
return False
qt_tools.set_item_data(widgetcbx, rows)
self.update_labels()
def filter_catalog(self):
node_node_type_new = qt_tools.getWidgetText(self.dlg_chg_node_type,
self.dlg_chg_node_type.node_node_type_new)
if node_node_type_new == "null":
return
# Populate catalog_id
sql = f"SELECT DISTINCT(id), id FROM cat_node WHERE nodetype_id = '{node_node_type_new}' ORDER BY id"
rows = self.controller.get_rows(sql)
qt_tools.set_item_data(self.dlg_chg_node_type.node_nodecat_id, rows, 1)
def populate_combos(self):
# Fill ComboBox state
sql = ("SELECT id, idval "
"FROM om_typevalue WHERE typevalue = 'mincut_state' "
"ORDER BY id")
rows = self.controller.get_rows(sql, add_empty_row=True)
qt_tools.set_item_data(self.dlg_min_edit.state_edit, rows, 1)
# Fill ComboBox exploitation
sql = "SELECT expl_id, name FROM exploitation WHERE expl_id > 0 ORDER BY name"
rows = self.controller.get_rows(sql, add_empty_row=True)
qt_tools.set_item_data(self.dlg_min_edit.cmb_expl, rows, 1)
def populate_time(self, combo_result, combo_time):
""" Populate combo times """
result_id = qt_tools.get_item_data(self.dlg_go2epa_result,
combo_result)
if self.project_type == 'ws':
field = "time"
else:
field = "resulttime"
sql = (f"SELECT DISTINCT {field}, {field} "
f"FROM rpt_arc "
f"WHERE result_id ILIKE '{result_id}' "
f"ORDER BY {field};")
rows = self.controller.get_rows(sql, add_empty_row=True)
qt_tools.set_item_data(combo_time, rows)
def ud_hydrology_selector(self):
""" Dialog hydrology_selector.ui """
self.dlg_hydrology_selector = HydrologySelector()
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 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
qt_tools.set_item_data(self.dlg_hydrology_selector.hydrology, rows)
sql = (
"SELECT DISTINCT(t1.name) FROM cat_hydrology AS t1 "
"INNER JOIN selector_inp_hydrology AS t2 ON t1.hydrology_id = t2.hydrology_id "
"WHERE t2.cur_user = current_user")
row = self.controller.get_row(sql)
if row:
qt_tools.setWidgetText(self.dlg_hydrology_selector,
self.dlg_hydrology_selector.hydrology,
row[0])
else:
qt_tools.setWidgetText(self.dlg_hydrology_selector,
self.dlg_hydrology_selector.hydrology, 0)
self.update_labels()
open_dialog(self.dlg_hydrology_selector)
def put_combobox(qtable, rows, field, widget_pos, combo_values):
""" Set one column of a QtableView as QComboBox with values from database.
:param qtable: QTableView to fill
:param rows: List of items to set QComboBox (["..", "..."])
:param field: Field to set QComboBox (String)
:param widget_pos: Position of the column where we want to put the QComboBox (integer)
:param combo_values: List of items to populate QComboBox (["..", "..."])
:return:
"""
for x in range(0, len(rows)):
combo = QComboBox()
row = rows[x]
# Populate QComboBox
qt_tools.set_item_data(combo, combo_values, 1)
# Set QCombobox to wanted item
qt_tools.set_combo_itemData(combo, str(row[field]), 1)
# Get index and put QComboBox into QTableView at index position
idx = qtable.model().index(x, widget_pos)
qtable.setIndexWidget(idx, combo)
# noinspection PyUnresolvedReferences
combo.currentIndexChanged.connect(partial(update_status, combo, qtable, x, widget_pos))
def manage_element(self,
new_element_id=True,
feature=None,
geom_type=None):
""" Button 33: Add element """
self.new_element_id = new_element_id
# Create the dialog and signals
self.dlg_add_element = ElementUi()
load_settings(self.dlg_add_element)
self.element_id = None
# Capture the current layer to return it at the end of the operation
cur_active_layer = self.iface.activeLayer()
set_selectionbehavior(self.dlg_add_element)
# Get layers of every geom_type
# Setting lists
self.ids = []
self.list_ids = {}
self.list_ids['arc'] = []
self.list_ids['node'] = []
self.list_ids['connec'] = []
self.list_ids['gully'] = []
self.list_ids['element'] = []
# Setting layers
self.layers = {}
self.layers['arc'] = []
self.layers['node'] = []
self.layers['connec'] = []
self.layers['gully'] = []
self.layers['element'] = []
self.layers['arc'] = self.controller.get_group_layers('arc')
self.layers['node'] = self.controller.get_group_layers('node')
self.layers['connec'] = self.controller.get_group_layers('connec')
self.layers['element'] = self.controller.get_group_layers('element')
# Remove 'gully' for 'WS'
self.project_type = self.controller.get_project_type()
if self.project_type == 'ws':
self.dlg_add_element.tab_feature.removeTab(3)
else:
self.layers['gully'] = self.controller.get_group_layers('gully')
# Set icons
set_icon(self.dlg_add_element.btn_add_geom, "133")
set_icon(self.dlg_add_element.btn_insert, "111")
set_icon(self.dlg_add_element.btn_delete, "112")
set_icon(self.dlg_add_element.btn_snapping, "137")
# Remove all previous selections
self.layers = remove_selection(True, layers=self.layers)
if feature:
layer = self.iface.activeLayer()
layer.selectByIds([feature.id()])
qt_tools.set_regexp_date_validator(self.dlg_add_element.builtdate,
self.dlg_add_element.btn_accept, 1)
# Get layer element and save if is visible or not for restore when finish process
layer_element = self.controller.get_layer_by_tablename(
"v_edit_element")
layer_is_visible = False
if layer_element:
layer_is_visible = self.controller.is_layer_visible(layer_element)
# Adding auto-completion to a QLineEdit
table_object = "element"
set_completer_object(self.dlg_add_element, table_object)
# Set signals
self.dlg_add_element.btn_accept.clicked.connect(
partial(self.manage_element_accept, table_object))
self.dlg_add_element.btn_accept.clicked.connect(
partial(self.controller.set_layer_visible, layer_element,
layer_is_visible))
# TODO: Set variable self.layers using return parameters
self.dlg_add_element.btn_cancel.clicked.connect(
partial(manage_close,
self.dlg_add_element,
table_object,
cur_active_layer,
excluded_layers=[],
layers=self.layers))
self.dlg_add_element.btn_cancel.clicked.connect(
partial(self.controller.set_layer_visible, layer_element,
layer_is_visible))
# TODO: Set variable self.layers using return parameters
self.dlg_add_element.rejected.connect(
partial(manage_close,
self.dlg_add_element,
table_object,
cur_active_layer,
excluded_layers=[],
layers=self.layers))
self.dlg_add_element.rejected.connect(
partial(self.controller.set_layer_visible, layer_element,
layer_is_visible))
self.dlg_add_element.tab_feature.currentChanged.connect(
partial(tab_feature_changed, self.dlg_add_element, table_object,
[]))
# TODO: Set variables self.ids, self.layers, self.list_ids using return parameters
self.dlg_add_element.element_id.textChanged.connect(
partial(exist_object,
self.dlg_add_element,
table_object,
layers=self.layers,
ids=self.ids,
list_ids=self.list_ids))
# TODO: Set variables self.ids, self.layers, self.list_ids using return parameters
self.dlg_add_element.btn_insert.clicked.connect(
partial(insert_feature,
self.dlg_add_element,
table_object,
geom_type=geom_type,
ids=self.ids,
layers=self.layers,
list_ids=self.list_ids))
# TODO: Set variables self.ids, self.layers, self.list_ids using return parameters
self.dlg_add_element.btn_delete.clicked.connect(
partial(delete_records,
self.dlg_add_element,
table_object,
geom_type=geom_type,
layers=self.layers,
ids=self.ids,
list_ids=self.list_ids))
# TODO: Set variables self.ids, self.layers, self.list_ids using return parameters
self.dlg_add_element.btn_snapping.clicked.connect(
partial(selection_init,
self.dlg_add_element,
table_object,
geom_type=geom_type,
layers=self.layers))
self.point_xy = self.dlg_add_element.btn_add_geom.clicked.connect(
partial(add_point, self.vertex_marker))
self.dlg_add_element.state.currentIndexChanged.connect(
partial(self.filter_state_type))
# Fill combo boxes of the form and related events
self.dlg_add_element.element_type.currentIndexChanged.connect(
partial(self.filter_elementcat_id))
self.dlg_add_element.element_type.currentIndexChanged.connect(
partial(self.update_location_cmb))
# TODO maybe all this values can be in one Json query
# Fill combo boxes
sql = "SELECT DISTINCT(elementtype_id), elementtype_id FROM cat_element ORDER BY elementtype_id"
rows = self.controller.get_rows(sql)
qt_tools.set_item_data(self.dlg_add_element.element_type, rows, 1)
sql = "SELECT expl_id, name FROM exploitation WHERE expl_id != '0' ORDER BY name"
rows = self.controller.get_rows(sql)
qt_tools.set_item_data(self.dlg_add_element.expl_id, rows, 1)
sql = "SELECT DISTINCT(id), name FROM value_state"
rows = self.controller.get_rows(sql)
qt_tools.set_item_data(self.dlg_add_element.state, rows, 1)
self.filter_state_type()
sql = ("SELECT location_type, location_type FROM man_type_location"
" WHERE feature_type = 'ELEMENT' "
" ORDER BY location_type")
rows = self.controller.get_rows(sql)
qt_tools.set_item_data(self.dlg_add_element.location_type, rows, 1)
if rows:
qt_tools.set_combo_itemData(self.dlg_add_element.location_type,
rows[0][0], 0)
sql = "SELECT DISTINCT(id), id FROM cat_owner"
rows = self.controller.get_rows(sql)
qt_tools.set_item_data(self.dlg_add_element.ownercat_id,
rows,
1,
add_empty=True)
sql = "SELECT DISTINCT(id), id FROM cat_builder"
rows = self.controller.get_rows(sql)
qt_tools.set_item_data(self.dlg_add_element.buildercat_id,
rows,
1,
add_empty=True)
sql = "SELECT DISTINCT(id), id FROM cat_work"
rows = self.controller.get_rows(sql)
qt_tools.set_item_data(self.dlg_add_element.workcat_id,
rows,
1,
add_empty=True)
self.dlg_add_element.workcat_id.currentIndexChanged.connect(
partial(self.set_style_sheet, self.dlg_add_element.workcat_id,
None))
sql = "SELECT DISTINCT(id), id FROM cat_work"
rows = self.controller.get_rows(sql)
qt_tools.set_item_data(self.dlg_add_element.workcat_id_end,
rows,
1,
add_empty=True)
sql = "SELECT id, idval FROM edit_typevalue WHERE typevalue = 'value_verified'"
rows = self.controller.get_rows(sql)
qt_tools.set_item_data(self.dlg_add_element.verified,
rows,
1,
add_empty=True)
self.filter_elementcat_id()
if self.new_element_id:
# Set default values
self.set_default_values()
# Adding auto-completion to a QLineEdit for default feature
set_completer_feature_id(self.dlg_add_element.feature_id, "arc",
"v_edit_arc")
if feature:
self.dlg_add_element.tabWidget.currentChanged.connect(
partial(self.fill_tbl_new_element, self.dlg_add_element,
geom_type, feature[geom_type + "_id"]))
# Set default tab 'arc'
self.dlg_add_element.tab_feature.setCurrentIndex(0)
self.geom_type = "arc"
tab_feature_changed(self.dlg_add_element, table_object)
# Force layer v_edit_element set active True
if layer_element:
self.controller.set_layer_visible(layer_element)
# If is a new element dont need set enddate
if self.new_element_id is True:
qt_tools.setWidgetText(self.dlg_add_element, 'num_elements', '1')
self.update_location_cmb()
if not self.new_element_id:
self.ids, self.layers, self.list_ids = exist_object(
self.dlg_add_element,
'element',
layers=self.layers,
ids=self.ids,
list_ids=self.list_ids)
# Open the dialog
open_dialog(self.dlg_add_element,
dlg_name='element',
maximize_button=False)
return self.dlg_add_element
def clicked_event(self):
""" Button 29: Epa result selector """
# Create the dialog and signals
self.dlg_go2epa_result = Go2EpaSelectorUi()
load_settings(self.dlg_go2epa_result)
if self.project_type == 'ud':
qt_tools.remove_tab_by_tabName(self.dlg_go2epa_result.tabWidget,
"tab_time")
if self.project_type == 'ws':
qt_tools.remove_tab_by_tabName(self.dlg_go2epa_result.tabWidget,
"tab_datetime")
self.dlg_go2epa_result.btn_accept.clicked.connect(
self.result_selector_accept)
self.dlg_go2epa_result.btn_cancel.clicked.connect(
partial(close_dialog, self.dlg_go2epa_result))
self.dlg_go2epa_result.rejected.connect(
partial(close_dialog, self.dlg_go2epa_result))
# Set values from widgets of type QComboBox
sql = ("SELECT DISTINCT(result_id), result_id "
"FROM v_ui_rpt_cat_result ORDER BY result_id")
rows = self.controller.get_rows(sql)
qt_tools.set_item_data(self.dlg_go2epa_result.rpt_selector_result_id,
rows)
rows = self.controller.get_rows(sql, add_empty_row=True)
qt_tools.set_item_data(self.dlg_go2epa_result.rpt_selector_compare_id,
rows)
if self.project_type == 'ws':
sql = ("SELECT DISTINCT time, time FROM rpt_arc "
"WHERE result_id ILIKE '%%' ORDER BY time")
rows = self.controller.get_rows(sql, add_empty_row=True)
qt_tools.set_item_data(self.dlg_go2epa_result.cmb_time_to_show,
rows)
qt_tools.set_item_data(self.dlg_go2epa_result.cmb_time_to_compare,
rows)
self.dlg_go2epa_result.rpt_selector_result_id.currentIndexChanged.connect(
partial(self.populate_time,
self.dlg_go2epa_result.rpt_selector_result_id,
self.dlg_go2epa_result.cmb_time_to_show))
self.dlg_go2epa_result.rpt_selector_compare_id.currentIndexChanged.connect(
partial(self.populate_time,
self.dlg_go2epa_result.rpt_selector_compare_id,
self.dlg_go2epa_result.cmb_time_to_compare))
elif self.project_type == 'ud':
# Populate GroupBox Selector date
result_id = qt_tools.get_item_data(
self.dlg_go2epa_result,
self.dlg_go2epa_result.rpt_selector_result_id, 0)
sql = (f"SELECT DISTINCT(resultdate), resultdate FROM rpt_arc "
f"WHERE result_id = '{result_id}' "
f"ORDER BY resultdate")
rows = self.controller.get_rows(sql)
if rows is not None:
qt_tools.set_item_data(self.dlg_go2epa_result.cmb_sel_date,
rows)
selector_date = qt_tools.get_item_data(
self.dlg_go2epa_result,
self.dlg_go2epa_result.cmb_sel_date, 0)
sql = (f"SELECT DISTINCT(resulttime), resulttime FROM rpt_arc "
f"WHERE result_id = '{result_id}' "
f"AND resultdate = '{selector_date}' "
f"ORDER BY resulttime")
rows = self.controller.get_rows(sql, add_empty_row=True)
qt_tools.set_item_data(self.dlg_go2epa_result.cmb_sel_time,
rows)
self.dlg_go2epa_result.rpt_selector_result_id.currentIndexChanged.connect(
partial(self.populate_date_time,
self.dlg_go2epa_result.cmb_sel_date))
self.dlg_go2epa_result.cmb_sel_date.currentIndexChanged.connect(
partial(self.populate_time,
self.dlg_go2epa_result.rpt_selector_result_id,
self.dlg_go2epa_result.cmb_sel_time))
# Populate GroupBox Selector compare
result_id_to_comp = qt_tools.get_item_data(
self.dlg_go2epa_result,
self.dlg_go2epa_result.rpt_selector_result_id, 0)
sql = (f"SELECT DISTINCT(resultdate), resultdate FROM rpt_arc "
f"WHERE result_id = '{result_id_to_comp}' "
f"ORDER BY resultdate ")
rows = self.controller.get_rows(sql)
if rows:
qt_tools.set_item_data(self.dlg_go2epa_result.cmb_com_date,
rows)
selector_cmp_date = qt_tools.get_item_data(
self.dlg_go2epa_result,
self.dlg_go2epa_result.cmb_com_date, 0)
sql = (f"SELECT DISTINCT(resulttime), resulttime FROM rpt_arc "
f"WHERE result_id = '{result_id_to_comp}' "
f"AND resultdate = '{selector_cmp_date}' "
f"ORDER BY resulttime")
rows = self.controller.get_rows(sql, add_empty_row=True)
qt_tools.set_item_data(self.dlg_go2epa_result.cmb_com_time,
rows)
self.dlg_go2epa_result.rpt_selector_compare_id.currentIndexChanged.connect(
partial(self.populate_date_time,
self.dlg_go2epa_result.cmb_com_date))
self.dlg_go2epa_result.cmb_com_date.currentIndexChanged.connect(
partial(self.populate_time,
self.dlg_go2epa_result.rpt_selector_compare_id,
self.dlg_go2epa_result.cmb_com_time))
# Get current data from tables 'rpt_selector_result' and 'rpt_selector_compare'
sql = "SELECT result_id FROM selector_rpt_main"
row = self.controller.get_row(sql)
if row:
qt_tools.set_combo_itemData(
self.dlg_go2epa_result.rpt_selector_result_id,
row["result_id"], 0)
sql = "SELECT result_id FROM selector_rpt_compare"
row = self.controller.get_row(sql)
if row:
qt_tools.set_combo_itemData(
self.dlg_go2epa_result.rpt_selector_compare_id,
row["result_id"], 0)
# Open the dialog
open_dialog(self.dlg_go2epa_result, dlg_name='go2epa_selector')
