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 load_parametric_values(self, dialog, function):
""" Load QGIS settings related with parametric toolbox options """
cur_user = self.controller.get_current_user()
function_name = function[0]['functionname']
layout = dialog.findChild(QWidget, 'grb_parameters')
widgets = layout.findChildren(QWidget)
for widget in widgets:
if type(widget) not in (QCheckBox, QComboBox, QLineEdit):
continue
if type(widget) is QCheckBox:
if self.controller.plugin_settings_value(
f"{function_name}_{cur_user}_{widget.objectName()}"):
widget.setChecked(True)
else:
widget.setChecked(False)
elif type(widget) is QComboBox:
if widget.property('selectedId') in (None, '', 'NULL'):
value = self.controller.plugin_settings_value(
f"{function_name}_{cur_user}_{widget.objectName()}")
else:
value = widget.property('selectedId')
qt_tools.set_combo_itemData(widget, value, 0)
elif type(widget) in (QLineEdit, QSpinBox):
value = self.controller.plugin_settings_value(
f"{function_name}_{cur_user}_{widget.objectName()}")
qt_tools.setWidgetText(dialog, widget, value)
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 load_parametric_values(self, dialog, function):
""" Load QGIS settings related with parametric toolbox options """
function_name = function[0]['functionname']
layout = dialog.findChild(QWidget, 'grb_parameters')
widgets = layout.findChildren(QWidget)
for widget in widgets:
if type(widget) not in (QCheckBox, QComboBox, QLineEdit,
QRadioButton):
continue
if type(widget) in (QCheckBox, QRadioButton):
value = get_parser_value(
'toolbox',
f"parametric_{function_name}_{widget.objectName()}")
qt_tools.setChecked(dialog, widget, value)
elif type(widget) is QComboBox:
if widget.property('selectedId') in (None, '', 'NULL'):
value = get_parser_value(
'toolbox',
f"parametric_{function_name}_{widget.objectName()}")
else:
value = widget.property('selectedId')
qt_tools.set_combo_itemData(widget, value, 0)
elif type(widget) in (QLineEdit, QSpinBox):
value = get_parser_value(
'toolbox',
f"parametric_{function_name}_{widget.objectName()}")
qt_tools.setWidgetText(dialog, widget, value)
def add_combobox(self, dialog, field):
widget = QComboBox()
widget.setObjectName(field['columnname'])
widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
self.populate_combo(widget, field)
if 'selectedId' in field:
qt_tools.set_combo_itemData(widget, field['selectedId'], 0)
return widget
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 add_combobox(self, field):
widget = QComboBox()
widget.setObjectName(field['widgetname'])
widget.setProperty('columnname', field['columnname'])
self.populate_combo(widget, field)
if 'selectedId' in field:
qt_tools.set_combo_itemData(widget, field['selectedId'], 0)
widget.currentIndexChanged.connect(partial(self.clear_lineedits))
return widget
def fill_widgets(dialog, table_object, row):
""" Fill input widgets with data int he @row """
if table_object == "doc":
qt_tools.setWidgetText(dialog, "doc_type", row["doc_type"])
qt_tools.setWidgetText(dialog, "observ", row["observ"])
qt_tools.setWidgetText(dialog, "path", row["path"])
elif table_object == "element":
state = ""
if row['state']:
sql = (f"SELECT name FROM value_state"
f" WHERE id = '{row['state']}'")
row_aux = global_vars.controller.get_row(sql)
if row_aux:
state = row_aux[0]
expl_id = ""
if row['expl_id']:
sql = (f"SELECT name FROM exploitation"
f" WHERE expl_id = '{row['expl_id']}'")
row_aux = global_vars.controller.get_row(sql)
if row_aux:
expl_id = row_aux[0]
qt_tools.setWidgetText(dialog, "code", row['code'])
sql = (f"SELECT elementtype_id FROM cat_element"
f" WHERE id = '{row['elementcat_id']}'")
row_type = global_vars.controller.get_row(sql)
if row_type:
qt_tools.setWidgetText(dialog, "element_type", row_type[0])
qt_tools.setWidgetText(dialog, "elementcat_id", row['elementcat_id'])
qt_tools.setWidgetText(dialog, "num_elements", row['num_elements'])
qt_tools.setWidgetText(dialog, "state", state)
qt_tools.set_combo_itemData(dialog.state_type, f"{row['state_type']}",
0)
qt_tools.setWidgetText(dialog, "expl_id", expl_id)
qt_tools.setWidgetText(dialog, "ownercat_id", row['ownercat_id'])
qt_tools.setWidgetText(dialog, "location_type", row['location_type'])
qt_tools.setWidgetText(dialog, "buildercat_id", row['buildercat_id'])
qt_tools.setWidgetText(dialog, "builtdate", row['builtdate'])
qt_tools.setWidgetText(dialog, "workcat_id", row['workcat_id'])
qt_tools.setWidgetText(dialog, "workcat_id_end", row['workcat_id_end'])
qt_tools.setWidgetText(dialog, "comment", row['comment'])
qt_tools.setWidgetText(dialog, "observ", row['observ'])
qt_tools.setWidgetText(dialog, "link", row['link'])
qt_tools.setWidgetText(dialog, "verified", row['verified'])
qt_tools.setWidgetText(dialog, "rotation", row['rotation'])
if str(row['undelete']) == 'True':
dialog.undelete.setChecked(True)
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 go2epa_options_get_data(self, tablename, dialog):
""" Get data from selected table """
sql = f"SELECT * FROM {tablename}"
row = self.controller.get_row(sql)
if not row:
message = "Any data found in table"
self.controller.show_warning(message, parameter=tablename)
return None
# Iterate over all columns and populate its corresponding widget
columns = []
for i in range(0, len(row)):
column_name = self.controller.dao.get_column_name(i)
widget = dialog.findChild(QWidget, column_name)
widget_type = qt_tools.getWidgetType(dialog, widget)
if row[column_name] is not None:
if widget_type is QCheckBox:
qt_tools.setChecked(dialog, widget, row[column_name])
elif widget_type is QComboBox:
qt_tools.set_combo_itemData(widget, row[column_name], 0)
elif widget_type is QDateEdit:
dateaux = row[column_name].replace('/', '-')
date = QDate.fromString(dateaux, 'dd-MM-yyyy')
qt_tools.setCalendarDate(dialog, widget, date)
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)
qt_tools.setTimeEdit(dialog, widget, time)
qt_tools.setText(dialog, column_name + "_day", days)
else:
qt_tools.setWidgetText(dialog, widget,
str(row[column_name]))
columns.append(column_name)
return columns
def populate_combo(self, widget, field):
# Generate list of items to add into combo
widget.blockSignals(True)
widget.clear()
widget.blockSignals(False)
combolist = []
if 'comboIds' in field:
for i in range(0, len(field['comboIds'])):
if field['comboIds'][i] is not None and field['comboNames'][
i] is not None:
elem = [field['comboIds'][i], field['comboNames'][i]]
combolist.append(elem)
records_sorted = sorted(combolist, key=operator.itemgetter(1))
# Populate combo
for record in records_sorted:
widget.addItem(record[1], record)
if 'value' in field:
if str(field['value']) != 'None':
qt_tools.set_combo_itemData(widget, field['value'], 0)
def load_settings_values(self, dialog, function):
""" Load QGIS settings related with toolbox options """
function_name = function[0]['functionname']
if dialog.cmb_geom_type.property('selectedId') in (None, '', 'NULL'):
geom_type = get_parser_value('toolbox',
f"{function_name}_cmb_geom_type")
else:
geom_type = dialog.cmb_geom_type.property('selectedId')
qt_tools.set_combo_itemData(dialog.cmb_geom_type, geom_type, 0)
if dialog.cmb_layers.property('selectedId') in (None, '', 'NULL'):
layer = get_parser_value('toolbox', f"{function_name}_cmb_layers")
else:
layer = dialog.cmb_layers.property('selectedId')
qt_tools.set_combo_itemData(dialog.cmb_layers, layer, 0)
if get_parser_value('toolbox',
f"{function_name}_rbt_previous") == 'True':
qt_tools.setChecked(dialog, 'rbt_previous', True)
else:
qt_tools.setChecked(dialog, 'rbt_layer', True)
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 load_settings_values(self, dialog, function):
""" Load QGIS settings related with toolbox options """
cur_user = self.controller.get_current_user()
function_name = function[0]['functionname']
if dialog.cmb_geom_type.property('selectedId') in (None, '', 'NULL'):
geom_type = self.controller.plugin_settings_value(
f"{function_name}_{cur_user}_cmb_geom_type")
else:
geom_type = dialog.cmb_geom_type.property('selectedId')
qt_tools.set_combo_itemData(dialog.cmb_geom_type, geom_type, 0)
if dialog.cmb_layers.property('selectedId') in (None, '', 'NULL'):
layer = self.controller.plugin_settings_value(
f"{function_name}_{cur_user}_cmb_layers")
else:
layer = dialog.cmb_layers.property('selectedId')
qt_tools.set_combo_itemData(dialog.cmb_layers, layer, 0)
if self.controller.plugin_settings_value(
f"{function_name}_{cur_user}_rbt_previous") == 'true':
dialog.rbt_previous.setChecked(True)
else:
dialog.rbt_layer.setChecked(True)
def manage_combo(self, combo, parameter):
row = self.controller.get_config(parameter)
if row:
qt_tools.set_combo_itemData(combo, row[0], 0)
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')
