def get_api_catalog(self, matcat_id, pnom, dnom, id, feature_type, geom_type):
matcat_id_value = qt_tools.get_item_data(self.dlg_catalog, matcat_id)
pn_value = qt_tools.get_item_data(self.dlg_catalog, pnom)
dn_value = qt_tools.get_item_data(self.dlg_catalog, dnom)
form_name = 'upsert_catalog_' + geom_type + ''
form = f'"formName":"{form_name}", "tabName":"data", "editable":"TRUE"'
feature = f'"feature_type":"{feature_type}"'
extras = None
if self.controller.get_project_type() == 'ws':
extras = f'"fields":{{"matcat_id":"{matcat_id_value}", "pnom":"{pn_value}", "dnom":"{dn_value}"}}'
elif self.controller.get_project_type() == 'ud':
extras = f'"fields":{{"matcat_id":"{matcat_id_value}", "shape":"{pn_value}", "geom1":"{dn_value}"}}'
body = create_body(form=form, feature=feature, extras=extras)
sql = f"SELECT gw_fct_getcatalog({body})::text"
row = self.controller.get_row(sql)
complet_result = [json.loads(row[0], object_pairs_hook=OrderedDict)]
if complet_result[0]['status'] == "Failed":
self.controller.log_warning(complet_result[0])
return False
if complet_result[0]['status'] == "Accepted":
result = complet_result[0]['body']['data']
for field in result['fields']:
if field['columnname'] == 'id':
self.populate_combo(id, field)
def save_settings_values(self, dialog, function):
""" Save QGIS settings related with toolbox options """
function_name = function[0]['functionname']
geom_type = qt_tools.get_item_data(dialog, dialog.cmb_geom_type, 0)
set_parser_value('toolbox', f"{function_name}_cmb_geom_type",
f"{geom_type}")
layer = qt_tools.get_item_data(dialog, dialog.cmb_layers, 0)
set_parser_value('toolbox', f"{function_name}_cmb_layers", f"{layer}")
set_parser_value('toolbox', f"{function_name}_rbt_previous",
f"{dialog.rbt_previous.isChecked()}")
def filter_by_id(self, qtable):
expr = ""
id_ = qt_tools.getWidgetText(self.dlg_min_edit, self.dlg_min_edit.txt_mincut_id, False, False)
state_id = qt_tools.get_item_data(self.dlg_min_edit, self.dlg_min_edit.state_edit, 0)
state_text = qt_tools.get_item_data(self.dlg_min_edit, self.dlg_min_edit.state_edit, 1)
expl = qt_tools.get_item_data(self.dlg_min_edit, self.dlg_min_edit.cmb_expl, 1)
dates_filter = ""
if state_id == '':
self.dlg_min_edit.date_from.setEnabled(False)
self.dlg_min_edit.date_to.setEnabled(False)
else:
self.dlg_min_edit.date_from.setEnabled(True)
self.dlg_min_edit.date_to.setEnabled(True)
# Get selected dates
visit_start = self.dlg_min_edit.date_from.date()
visit_end = self.dlg_min_edit.date_to.date()
date_from = visit_start.toString('yyyyMMdd 00:00:00')
date_to = visit_end.toString('yyyyMMdd 23:59:59')
if date_from > date_to:
message = "Selected date interval is not valid"
self.controller.show_warning(message)
return
# Create interval dates
format_low = 'yyyy-MM-dd 00:00:00.000'
format_high = 'yyyy-MM-dd 23:59:59.999'
interval = f"'{visit_start.toString(format_low)}'::timestamp AND '{visit_end.toString(format_high)}'::timestamp"
if str(state_id) in ('0', '3'):
qt_tools.setWidgetText(self.dlg_min_edit, self.dlg_min_edit.lbl_date_from, 'Date from: forecast_start')
qt_tools.setWidgetText(self.dlg_min_edit, self.dlg_min_edit.lbl_date_to, 'Date to: forecast_end')
dates_filter = f"AND (forecast_start BETWEEN {interval}) AND (forecast_end BETWEEN {interval})"
elif str(state_id) in ('1', '2'):
qt_tools.setWidgetText(self.dlg_min_edit, self.dlg_min_edit.lbl_date_from, 'Date from: exec_start')
qt_tools.setWidgetText(self.dlg_min_edit, self.dlg_min_edit.lbl_date_to, 'Date to: exec_end')
dates_filter = f"AND (exec_start BETWEEN {interval}) AND (exec_end BETWEEN {interval})"
else:
qt_tools.setWidgetText(self.dlg_min_edit, self.dlg_min_edit.lbl_date_from, 'Date from:')
qt_tools.setWidgetText(self.dlg_min_edit, self.dlg_min_edit.lbl_date_to, 'Date to:')
expr += f" (id::text ILIKE '%{id_}%'"
expr += f" OR work_order::text ILIKE '%{id_}%')"
expr += f" {dates_filter}"
if state_text != '':
expr += f" AND state::text ILIKE '%{state_text}%' "
expr += f" AND (exploitation::text ILIKE '%{expl}%' OR exploitation IS null)"
# Refresh model with selected filter
qtable.model().setFilter(expr)
qtable.model().select()
def save_settings_values(self, dialog, function):
""" Save QGIS settings related with toolbox options """
cur_user = self.controller.get_current_user()
function_name = function[0]['functionname']
geom_type = qt_tools.get_item_data(dialog, dialog.cmb_geom_type, 0)
self.controller.plugin_settings_set_value(
f"{function_name}_{cur_user}_cmb_geom_type", geom_type)
layer = qt_tools.get_item_data(dialog, dialog.cmb_layers, 0)
self.controller.plugin_settings_set_value(
f"{function_name}_{cur_user}_cmb_layers", layer)
self.controller.plugin_settings_set_value(
f"{function_name}_{cur_user}_rbt_previous",
dialog.rbt_previous.isChecked())
def get_values_checked_param_user(self, chk, widget, field, value=None):
elem = {}
elem['widget'] = str(widget.objectName())
elem['chk'] = str(chk.objectName())
if type(widget) is QLineEdit:
value = qt_tools.getWidgetText(self.dlg_config,
widget,
return_string_null=False)
elem['widget_type'] = 'text'
elif type(widget) is QComboBox:
value = qt_tools.get_item_data(self.dlg_config, widget, 0)
elem['widget_type'] = 'combo'
elif type(widget) is QCheckBox:
value = qt_tools.isChecked(self.dlg_config, chk)
elem['widget_type'] = 'check'
elif type(widget) is QDateEdit:
value = qt_tools.getCalendarDate(self.dlg_config, widget)
elem['widget_type'] = 'datetime'
elif type(widget) is QgsDateTimeEdit:
value = qt_tools.getCalendarDate(self.dlg_config, widget)
elem['widget_type'] = 'datetime'
elem['isChecked'] = str(qt_tools.isChecked(self.dlg_config, chk))
elem['value'] = value
self.list_update.append(elem)
def save_user_values(self):
""" Save selected user values """
host = qt_tools.getWidgetText(self.dlg_qm,
self.dlg_qm.txt_host,
return_string_null=False)
port = qt_tools.getWidgetText(self.dlg_qm,
self.dlg_qm.txt_port,
return_string_null=False)
db = qt_tools.getWidgetText(self.dlg_qm,
self.dlg_qm.txt_db,
return_string_null=False)
user = qt_tools.getWidgetText(self.dlg_qm,
self.dlg_qm.txt_user,
return_string_null=False)
language = qt_tools.get_item_data(self.dlg_qm,
self.dlg_qm.cmb_language, 0)
py_msg = qt_tools.isChecked(self.dlg_qm, self.dlg_qm.chk_py_msg)
db_msg = qt_tools.isChecked(self.dlg_qm, self.dlg_qm.chk_db_msg)
set_parser_value('i18n_generator', 'qm_lang_host', f"{host}")
set_parser_value('i18n_generator', 'qm_lang_port', f"{port}")
set_parser_value('i18n_generator', 'qm_lang_db', f"{db}")
set_parser_value('i18n_generator', 'qm_lang_user', f"{user}")
set_parser_value('i18n_generator', 'qm_lang_language', f"{language}")
set_parser_value('i18n_generator', 'qm_lang_py_msg', f"{py_msg}")
set_parser_value('i18n_generator', 'qm_lang_db_msg', f"{db_msg}")
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 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 insert_into_db(self, dialog, csvfile, delimiter, _unicode):
sql = ""
progress = 0
dialog.progressBar.setVisible(True)
dialog.progressBar.setValue(progress)
# counts rows in csvfile, using var "row_count" to do progressbar
# noinspection PyUnusedLocal
row_count = sum(1 for rows in csvfile)
if row_count > 20:
row_count -= 20
dialog.progressBar.setMaximum(
row_count) # -20 for see 100% complete progress
csvfile.seek(0) # Position the cursor at position 0 of the file
reader = csv.reader(csvfile, delimiter=delimiter)
fid_aux = qt_tools.get_item_data(dialog, dialog.cmb_import_type, 0)
readheader = qt_tools.get_item_data(dialog, dialog.cmb_import_type, 4)
for row in reader:
if readheader is False:
readheader = True
continue
if len(row) > 0:
sql += "INSERT INTO temp_csv (fid, "
values = f"VALUES({fid_aux}, "
for x in range(0, len(row)):
sql += f"csv{x + 1}, "
value = f"$$" + row[x].strip().replace("\n", "") + "$$, "
value = str(value)
values += value.replace("$$$$", "null")
sql = sql[:-2] + ") "
values = values[:-2] + ");\n"
sql += values
progress += 1
dialog.progressBar.setValue(progress)
if progress % 500 == 0:
status = self.controller.execute_sql(sql)
if not status:
return False
sql = ""
if sql != "":
status = self.controller.execute_sql(sql)
if not status:
return False
return True
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 fill_child(self, widget, geom_type):
combo_parent = widget.objectName()
combo_id = qt_tools.get_item_data(self.dlg_catalog, widget)
# TODO cambiar por gw_fct_getchilds
sql = f"SELECT gw_fct_getcombochilds('catalog' ,'' ,'' ,'{combo_parent}', '{combo_id}','{geom_type}')"
row = self.controller.get_row(sql)
for combo_child in row[0]['fields']:
if combo_child is not None:
self.populate_child(combo_child, row)
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 set_selected_layer(self, dialog, combo):
layer_name = qt_tools.get_item_data(dialog, combo, 1)
layer = self.controller.get_layer_by_tablename(layer_name)
if layer is None:
self.controller.show_warning("Layer not found",
parameter=layer_name)
return None
self.iface.setActiveLayer(layer)
return layer
def get_files_db_messages(self):
""" Read the values of the database and update the i18n api files """
db_lang = qt_tools.get_item_data(self.dlg_qm, self.dlg_qm.cmb_language,
1)
file_lng = qt_tools.get_item_data(self.dlg_qm,
self.dlg_qm.cmb_language, 3)
version_metadata = get_plugin_version()
ver = version_metadata.split('.')
plugin_version = f'{ver[0]}{ver[1]}'
plugin_release = version_metadata.replace('.', '')
# Get db messages values
sql = (
f"SELECT source, project_type, context, formname, formtype, lb_enen, lb_{db_lang}, tt_enen, tt_{db_lang} "
f" FROM i18n.dbdialog "
f" WHERE context not in ('config_param_system', 'sys_param_user')"
f" ORDER BY formname;")
rows = self.get_rows(sql)
if not rows:
return
db_path = (self.plugin_dir + os.sep + 'sql' + os.sep + 'api' + os.sep +
'updates' + os.sep + f'{plugin_version}' + '' + os.sep +
f"{plugin_release}" + os.sep + 'i18n' + os.sep +
f'{file_lng}' + os.sep + '')
file_name = f'dml.sql'
# Check if file exist
if os.path.exists(db_path + file_name):
msg = "Are you sure you want to overwrite this file?"
answer = self.controller.ask_question(
msg,
"Overwrite",
parameter=f"\n\n{db_path}{os.sep}{file_name}")
if not answer:
return False
else:
os.makedirs(db_path, exist_ok=True)
status = self.write_values(rows, db_path + file_name)
return status
def fill_child(self, widget):
combo_parent = widget.objectName()
combo_id = qt_tools.get_item_data(self.dlg_config, widget)
# TODO cambiar por gw_fct_getchilds
sql = f"SELECT gw_fct_getcombochilds('config' ,'' ,'' ,'{combo_parent}', '{combo_id}','')"
row = self.controller.get_row(sql)
# TODO::Refactor input and output for function "gw_fct_getcombochilds" and refactor "row[0]['fields']"
for combo_child in row[0]['fields']:
if combo_child is not None:
self.populate_child(combo_child)
def fill_child(self, dialog, widget):
combo_parent = widget.objectName()
combo_id = qt_tools.get_item_data(self.dlg_options, widget)
json_result = self.controller.get_json('gw_fct_getcombochilds', f"'epaoptions', '', '', '{combo_parent}', '{combo_id}', ''")
if not json_result:
return False
for combo_child in json_result['fields']:
if combo_child is not None:
manage_child(dialog, widget, combo_child)
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 save_parametric_values(self, dialog, function):
""" Save 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) is QCheckBox:
self.controller.plugin_settings_set_value(
f"{function_name}_{cur_user}_{widget.objectName()}",
widget.isChecked())
elif type(widget) is QComboBox:
value = qt_tools.get_item_data(dialog, widget, 0)
self.controller.plugin_settings_set_value(
f"{function_name}_{cur_user}_{widget.objectName()}", value)
elif type(widget) in (QLineEdit, QSpinBox):
value = qt_tools.getWidgetText(dialog, widget, False, False)
self.controller.plugin_settings_set_value(
f"{function_name}_{cur_user}_{widget.objectName()}", value)
def save_hydrology(self):
hydrology_id = qt_tools.get_item_data(
self.dlg_hydrology_selector, self.dlg_hydrology_selector.hydrology,
1)
sql = ("SELECT cur_user FROM selector_inp_hydrology "
"WHERE cur_user = current_user")
row = self.controller.get_row(sql)
if row:
sql = (f"UPDATE selector_inp_hydrology "
f"SET hydrology_id = {hydrology_id} "
f"WHERE cur_user = current_user")
else:
sql = (
f"INSERT INTO selector_inp_hydrology (hydrology_id, cur_user) "
f"VALUES('{hydrology_id}', current_user)")
self.controller.execute_sql(sql)
message = "Values has been update"
self.controller.show_info(message)
close_dialog(self.dlg_hydrology_selector)
def write_csv(self, dialog, temp_tablename):
""" Write csv in postgres and call gw_fct_utils_csv2pg function """
self.save_settings_values()
insert_status = True
if not self.validate_params(dialog):
return
fid_aux = qt_tools.get_item_data(dialog, dialog.cmb_import_type, 0)
self.delete_table_csv(temp_tablename, fid_aux)
path = qt_tools.getWidgetText(dialog, dialog.txt_file_csv)
label_aux = qt_tools.getWidgetText(dialog,
dialog.txt_import,
return_string_null=False)
delimiter = self.get_delimiter(dialog)
_unicode = qt_tools.getWidgetText(dialog, dialog.cmb_unicode_list)
try:
with open(path, 'r', encoding=_unicode) as csvfile:
insert_status = self.insert_into_db(dialog, csvfile, delimiter,
_unicode)
csvfile.close()
del csvfile
except Exception as e:
self.controller.show_warning("EXCEPTION: " + str(e))
if insert_status is False:
return
extras = f'"importParam":"{label_aux}"'
extras += f', "fid":"{fid_aux}"'
body = create_body(extras=extras)
result = self.controller.get_json(self.func_name, body)
if not result:
return
else:
if result['status'] == "Accepted":
populate_info_text(dialog, result['body']['data'])
msg = result['message']['text']
self.controller.show_info_box(msg)
def duplicate_psector(self):
id_psector = qt_tools.get_item_data(
self.dlg_duplicate_psector,
self.dlg_duplicate_psector.duplicate_psector, 0)
new_psector_name = qt_tools.getWidgetText(
self.dlg_duplicate_psector,
self.dlg_duplicate_psector.new_psector_name)
# Create body
feature = '"type":"PSECTOR"'
extras = f'"psector_id":"{id_psector}", "new_psector_name":"{new_psector_name}"'
body = create_body(feature=feature, extras=extras)
body = body.replace('""', 'null')
complet_result = self.controller.get_json('gw_fct_psector_duplicate',
body)
if not complet_result:
message = 'Function gw_fct_psector_duplicate executed with no result'
self.controller.show_message(message, 3)
return
# Populate tab info
change_tab = False
data = complet_result['body']['data']
for k, v in list(data.items()):
if str(k) == "info":
change_tab = populate_info_text(self.dlg_duplicate_psector,
data)
# Close dialog
if not change_tab:
close_dialog(self.dlg_duplicate_psector)
else:
qt_tools.getWidget(
self.dlg_duplicate_psector,
self.dlg_duplicate_psector.btn_accept).setEnabled(False)
self.dlg_duplicate_psector.setWindowTitle(
f'SUCCESS IN DUPLICATING PSECTOR')
self.is_duplicated.emit()
def populate_pn_dn(self, matcat_id, pnom, dnom, feature_type, geom_type):
matcat_id_value = qt_tools.get_item_data(self.dlg_catalog, matcat_id)
form_name = f'upsert_catalog_' + geom_type + ''
form = f'"formName":"{form_name}", "tabName":"data", "editable":"TRUE"'
feature = f'"feature_type":"{feature_type}"'
extras = f'"fields":{{"matcat_id":"{matcat_id_value}"}}'
body = create_body(form=form, feature=feature, extras=extras)
sql = f"SELECT gw_fct_getcatalog({body})::text"
row = self.controller.get_row(sql)
complet_list = [json.loads(row[0], object_pairs_hook=OrderedDict)]
result = complet_list[0]['body']['data']
for field in result['fields']:
if field['columnname'] == 'pnom':
self.populate_combo(pnom, field)
elif field['columnname'] == 'dnom':
self.populate_combo(dnom, field)
elif field['columnname'] == 'shape':
self.populate_combo(pnom, field)
elif field['columnname'] == 'geom1':
self.populate_combo(dnom, field)
def get_values_changed_param_system(self, widget, value=None):
elem = {}
if type(widget) is QLineEdit:
value = qt_tools.getWidgetText(self.dlg_config,
widget,
return_string_null=False)
elif type(widget) is QComboBox:
value = qt_tools.get_item_data(self.dlg_config, widget, 0)
elif type(widget) is QCheckBox:
value = qt_tools.isChecked(self.dlg_config, widget)
elif type(widget) is QDateEdit:
value = qt_tools.getCalendarDate(self.dlg_config, widget)
elem['widget'] = str(widget.objectName())
elem['chk'] = str('')
elem['isChecked'] = str('')
elem['value'] = value
elem['sysRoleId'] = 'role_admin'
self.list_update.append(elem)
def save_parametric_values(self, dialog, function):
""" Save 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) is QCheckBox:
set_parser_value(
'toolbox',
f"parametric_{function_name}_{widget.objectName()}",
f"{widget.isChecked()}")
elif type(widget) is QComboBox:
value = qt_tools.get_item_data(dialog, widget, 0)
set_parser_value(
'toolbox',
f"parametric_{function_name}_{widget.objectName()}",
f"{value}")
elif type(widget) in (QLineEdit, QSpinBox):
value = qt_tools.getWidgetText(dialog, widget, False, False)
set_parser_value(
'toolbox',
f"parametric_{function_name}_{widget.objectName()}",
f"{value}")
def manage_workcat_end_accept(self):
""" Get elements from all the tables and update his data """
# Setting values
self.workcat_id_end = qt_tools.getWidgetText(
self.dlg_work_end, self.dlg_work_end.workcat_id_end)
self.enddate = qt_tools.getCalendarDate(self.dlg_work_end,
self.dlg_work_end.enddate)
self.statetype_id_end = qt_tools.get_item_data(
self.dlg_work_end, self.dlg_work_end.cmb_statetype_end, 0)
if self.workcat_id_end in ('null', None):
message = "Please select a workcat id end"
self.controller.show_warning(message)
return
ids_list = self.get_list_selected_id(
self.dlg_work_end.tbl_cat_work_x_arc)
row = None
if ids_list:
sql = (f"SELECT * FROM v_ui_arc_x_relations "
f"WHERE arc_id IN ( {ids_list}) AND arc_state = '1'")
row = self.controller.get_row(sql)
if row:
self.dlg_work = FeatureEndConnecUi()
self.load_settings(self.dlg_work)
self.dlg_work.btn_cancel.clicked.connect(
partial(self.close_dialog_workcat_list, self.dlg_work))
self.dlg_work.btn_accept.clicked.connect(self.exec_downgrade)
self.set_completer()
table_relations = "v_ui_arc_x_relations"
self.dlg_work.arc_id.textChanged.connect(
partial(self.filter_by_id, self.dlg_work.tbl_arc_x_relations,
self.dlg_work.arc_id, table_relations))
self.tbl_arc_x_relations = self.dlg_work.findChild(
QTableView, "tbl_arc_x_relations")
self.tbl_arc_x_relations.setSelectionBehavior(
QAbstractItemView.SelectRows)
filter_ = ""
for row in self.selected_list:
filter_ += f"arc_id = '{row}' OR "
filter_ = filter_[:-3] + ""
filter_ += " AND arc_state = '1' "
self.fill_table(self.tbl_arc_x_relations, table_relations, filter_)
self.tbl_arc_x_relations.doubleClicked.connect(
partial(self.open_selected_object, self.tbl_arc_x_relations))
self.open_dialog(self.dlg_work, dlg_name='feature_end_connec')
# TODO: Function update_geom_type() don't use parameter ids_list
else:
# Update tablename of every geom_type
ids_list = self.get_list_selected_id(
self.dlg_work_end.tbl_cat_work_x_arc)
self.update_geom_type("arc", ids_list)
ids_list = self.get_list_selected_id(
self.dlg_work_end.tbl_cat_work_x_node)
self.update_geom_type("node", ids_list)
ids_list = self.get_list_selected_id(
self.dlg_work_end.tbl_cat_work_x_connec)
self.update_geom_type("connec", ids_list)
ids_list = self.get_list_selected_id(
self.dlg_work_end.tbl_cat_work_x_element)
self.update_geom_type("element", ids_list)
if str(self.project_type) == 'ud':
ids_list = self.get_list_selected_id(
self.dlg_work_end.tbl_cat_work_x_gully)
self.update_geom_type("gully", ids_list)
self.manage_close(self.dlg_work_end,
self.table_object,
self.cur_active_layer,
force_downgrade=True)
# Remove selection for all layers in TOC
for layer in self.iface.mapCanvas().layers():
if layer.type() == layer.VectorLayer:
layer.removeSelection()
self.iface.mapCanvas().refresh()
def get_function_name(self):
self.func_name = qt_tools.get_item_data(self.dlg_csv, self.dlg_csv.cmb_import_type, 3)
self.controller.log_info(str(self.func_name))
def update_info(self, dialog):
""" Update the tag according to item selected from cmb_import_type """
dialog.lbl_info.setText(qt_tools.get_item_data(self.dlg_csv, self.dlg_csv.cmb_import_type, 2))
def make_list(self, completer, model, widget):
""" Create a list of ids and populate widget (QLineEdit) """
# Create 2 json, one for first QLineEdit and other for second QLineEdit
form_search = ''
extras_search = ''
form_search_add = ''
extras_search_add = ''
result = None
index = self.dlg_search.main_tab.currentIndex()
combo_list = self.dlg_search.main_tab.widget(index).findChildren(
QComboBox)
line_list = self.dlg_search.main_tab.widget(index).findChildren(
QLineEdit)
form_search += f'"tabName":"{self.dlg_search.main_tab.widget(index).objectName()}"'
form_search_add += f'"tabName":"{self.dlg_search.main_tab.widget(index).objectName()}"'
if combo_list:
combo = combo_list[0]
id = qt_tools.get_item_data(self.dlg_search, combo, 0)
name = qt_tools.get_item_data(self.dlg_search, combo, 1)
try:
feature_type = qt_tools.get_item_data(self.dlg_search, combo,
2)
extras_search += f'"searchType":"{feature_type}", '
except IndexError:
pass
extras_search += f'"{combo.property("columnname")}":{{"id":"{id}", "name":"{name}"}}, '
extras_search_add += f'"{combo.property("columnname")}":{{"id":"{id}", "name":"{name}"}}, '
if line_list:
line_edit = line_list[0]
# If current tab have more than one QLineEdit, clear second QLineEdit
if len(line_list) == 2:
line_edit.textChanged.connect(
partial(self.clear_line_edit_add, line_list))
value = qt_tools.getWidgetText(self.dlg_search,
line_edit,
return_string_null=False)
if str(value) == '':
return
qgis_project_add_schema = self.controller.plugin_settings_value(
'gwAddSchema')
extras_search += f'"{line_edit.property("columnname")}":{{"text":"{value}"}}, '
extras_search += f'"addSchema":"{qgis_project_add_schema}"'
extras_search_add += f'"{line_edit.property("columnname")}":{{"text":"{value}"}}'
body = create_body(form=form_search, extras=extras_search)
result = self.controller.get_json('gw_fct_setsearch',
body,
rubber_band=self.rubber_band)
if not result:
return False
if result:
self.result_data = result
# Set label visible
if result:
if self.result_data['data'] == {} and self.lbl_visible:
self.dlg_search.lbl_msg.setVisible(True)
if len(line_list) == 2:
widget_add = line_list[1]
widget_add.setReadOnly(True)
widget_add.setStyleSheet(
"QLineEdit { background: rgb(242, 242, 242); color: rgb(100, 100, 100)}"
)
else:
self.lbl_visible = True
self.dlg_search.lbl_msg.setVisible(False)
# Get list of items from returned json from data base and make a list for completer
display_list = []
for data in self.result_data['data']:
display_list.append(data['display_name'])
set_completer_object_api(completer, model, widget, display_list)
if len(line_list) == 2:
line_edit_add = line_list[1]
value = qt_tools.getWidgetText(self.dlg_search, line_edit_add)
if str(value) == 'null':
return
extras_search_add += f', "{line_edit_add.property("columnname")}":{{"text":"{value}"}}'
body = create_body(form=form_search_add, extras=extras_search_add)
result = self.controller.get_json('gw_fct_setsearchadd',
body,
rubber_band=self.rubber_band)
if not result:
return False
if result:
self.result_data = result
if result is not None:
display_list = []
for data in self.result_data['data']:
display_list.append(data['display_name'])
set_completer_object_api(completer, model, line_edit_add,
display_list)
def execute_function(self, dialog, combo, result):
dialog.btn_cancel.setEnabled(False)
dialog.progressBar.setMaximum(0)
dialog.progressBar.setMinimum(0)
dialog.progressBar.setVisible(True)
extras = ''
feature_field = ''
# TODO Check if time functions is short or long, activate and set undetermined if not short
# Get function name
function = None
function_name = None
for group, function in list(result['fields'].items()):
if len(function) != 0:
self.save_settings_values(dialog, function)
self.save_parametric_values(dialog, function)
function_name = function[0]['functionname']
break
if function_name is None:
return
# If function is not parametrized, call function(old) without json
if self.is_paramtetric is False:
self.execute_no_parametric(dialog, function_name)
dialog.progressBar.setVisible(False)
dialog.progressBar.setMinimum(0)
dialog.progressBar.setMaximum(1)
dialog.progressBar.setValue(1)
return
if function[0]['input_params']['featureType']:
layer = None
layer_name = qt_tools.get_item_data(dialog, combo, 1)
if layer_name != -1:
layer = self.set_selected_layer(dialog, combo)
if not layer:
dialog.progressBar.setVisible(False)
dialog.progressBar.setMinimum(0)
dialog.progressBar.setMaximum(1)
dialog.progressBar.setValue(1)
return
selection_mode = self.rbt_checked['widget']
extras += f'"selectionMode":"{selection_mode}",'
# Check selection mode and get (or not get) all feature id
feature_id_list = '"id":['
if (selection_mode == 'wholeSelection') or (
selection_mode == 'previousSelection' and layer is None):
feature_id_list += ']'
elif selection_mode == 'previousSelection' and layer is not None:
features = layer.selectedFeatures()
feature_type = qt_tools.get_item_data(dialog,
dialog.cmb_geom_type, 0)
for feature in features:
feature_id = feature.attribute(feature_type + "_id")
feature_id_list += f'"{feature_id}", '
if len(features) > 0:
feature_id_list = feature_id_list[:-2] + ']'
else:
feature_id_list += ']'
if layer_name != -1:
feature_field = f'"tableName":"{layer_name}", '
feature_type = qt_tools.get_item_data(dialog,
dialog.cmb_geom_type, 0)
feature_field += f'"featureType":"{feature_type}", '
feature_field += feature_id_list
widget_list = dialog.grb_parameters.findChildren(QWidget)
widget_is_void = False
extras += '"parameters":{'
for group, function in list(result['fields'].items()):
if len(function) != 0:
if function[0]['return_type'] not in (None, ''):
for field in function[0]['return_type']:
widget = dialog.findChild(QWidget, field['widgetname'])
param_name = widget.objectName()
if type(widget) in ('', QLineEdit):
widget.setStyleSheet(None)
value = qt_tools.getWidgetText(
dialog, widget, False, False)
extras += f'"{param_name}":"{value}", '.replace(
'""', 'null')
if value is '' and widget.property('ismandatory'):
widget_is_void = True
widget.setStyleSheet("border: 1px solid red")
elif type(widget) in ('', QSpinBox, QDoubleSpinBox):
value = qt_tools.getWidgetText(
dialog, widget, False, False)
if value == '':
value = 0
extras += f'"{param_name}":"{value}", '
elif type(widget) in ('', QComboBox):
value = qt_tools.get_item_data(dialog, widget, 0)
extras += f'"{param_name}":"{value}", '
elif type(widget) in ('', QCheckBox):
value = qt_tools.isChecked(dialog, widget)
extras += f'"{param_name}":"{str(value).lower()}", '
elif type(widget) in ('', QgsDateTimeEdit):
value = qt_tools.getCalendarDate(dialog, widget)
if value == "" or value is None:
extras += f'"{param_name}":null, '
else:
extras += f'"{param_name}":"{value}", '
if widget_is_void:
message = "This param is mandatory. Please, set a value"
self.controller.show_warning(message, parameter='')
dialog.progressBar.setVisible(False)
dialog.progressBar.setMinimum(0)
dialog.progressBar.setMaximum(1)
dialog.progressBar.setValue(1)
return
dialog.progressBar.setFormat(f"Running function: {function_name}")
dialog.progressBar.setAlignment(Qt.AlignCenter)
if len(widget_list) > 0:
extras = extras[:-2] + '}'
else:
extras += '}'
body = self.create_body(feature=feature_field, extras=extras)
json_result = self.controller.get_json(function_name,
body,
log_sql=True)
self.add_layer.populate_info_text(dialog, json_result['body']['data'],
True, True, 1, True)
dialog.progressBar.setAlignment(Qt.AlignCenter)
dialog.progressBar.setMinimum(0)
dialog.progressBar.setMaximum(1)
dialog.progressBar.setValue(1)
if json_result is None:
dialog.progressBar.setFormat(
f"Function: {function_name} executed with no result")
return True
if not json_result:
dialog.progressBar.setFormat(
f"Function: {function_name} failed. See log file for more details"
)
return False
try:
dialog.progressBar.setFormat(
f"Function {function_name} has finished")
# getting simbology capabilities
if 'setStyle' in json_result['body']['data']:
set_sytle = json_result['body']['data']['setStyle']
if set_sytle == "Mapzones":
# call function to simbolize mapzones
self.set_style_mapzones()
except KeyError as e:
msg = f"<b>Key: </b>{e}<br>"
msg += f"<b>key container: </b>'body/data/ <br>"
msg += f"<b>Python file: </b>{__name__} <br>"
msg += f"<b>Python function:</b> {self.execute_function.__name__} <br>"
self.show_exceptions_msg(
"Key on returned json from ddbb is missed.", msg)
self.remove_layers()
def write_values(self, rows, path):
""" Generate a string and write into file
:param rows: List of values ([List][list])
:param path: Full destination path (String)
:return: (Boolean)
"""
file = open(path, "w")
db_lang = qt_tools.get_item_data(self.dlg_qm, self.dlg_qm.cmb_language,
1)
header = (
f'/*\n'
f'This file is part of Giswater 3\n'
f'The program is free software: you can redistribute it and/or modify it under the terms of the GNU '
f'General Public License as published by the Free Software Foundation, either version 3 of the '
f'License, or (at your option) any later version.\n'
f'This version of Giswater is provided by Giswater Association,\n'
f'*/\n\n\n'
f'SET search_path = SCHEMA_NAME, public, pg_catalog;\n\n')
file.write(header)
for row in rows:
table = row['context']
form_name = row['formname']
form_type = row['formtype']
source = row['source']
lbl_value = row[f'lb_{db_lang}'] if row[
f'lb_{db_lang}'] is not None else row['lb_enen']
if row[f'tt_{db_lang}'] is not None:
tt_value = row[f'tt_{db_lang}']
elif row[f'tt_enen'] is not None:
tt_value = row[f'tt_enen']
else:
tt_value = row['lb_enen']
line = f'SELECT gw_fct_admin_schema_i18n($$'
if row['context'] in ('config_param_system', 'sys_param_user'):
line += (
f'{{"data":'
f'{{"table":"{table}", '
f'"formname":"{form_name}", '
f'"label":{{"column":"label", "value":"{lbl_value}"}}, '
f'"tooltip":{{"column":"descript", "value":"{tt_value}"}}')
elif row['context'] not in ('config_param_system',
'sys_param_user'):
line += (
f'{{"data":'
f'{{"table":"{table}", '
f'"formname":"{form_name}", '
f'"label":{{"column":"label", "value":"{lbl_value}"}}, '
f'"tooltip":{{"column":"tooltip", "value":"{tt_value}"}}')
# Clause WHERE for each context
if row['context'] == 'config_api_form_fields':
line += (
f', "clause":"WHERE columnname = \'{source}\' '
f'AND formname = \'{form_name}\' AND formtype = \'{form_type}\'"'
)
elif row['context'] == 'config_api_form_tabs':
line += (
f', "clause":"WHERE formname = \'{form_name}\' '
f'AND columnname = \'{source}\' AND formtype = \'{form_type}\'"'
)
elif row['context'] == 'config_api_form_groupbox':
line += (f', "clause":"WHERE formname = \'{form_name}\' '
f'AND layout_id = \'{source}\'"')
elif row['context'] == 'config_api_form_actions':
line += f', "clause":"WHERE actioname = \'{source}\''
elif row['context'] in ('config_param_system', 'sys_param_user'):
line += f', "clause":"WHERE parameter = \'{source}\'"'
line += f'}}}}$$);\n'
file.write(line)
file.close()
del file
return True
