def refresh_models_for_active_role(self, only_for_model=''):
role_key = RoleRegistry().get_active_role()
role_models = RoleRegistry().get_role_models(role_key)
# ili2db params may come from the model config itself or overwritten by the current user.
# If the user does not have such config, we grab it from MODEL_CONFIG.
ili2db_params = role_models.get(ROLE_MODEL_ILI2DB_PARAMETERS, dict())
for model_key, model in self.__models.items():
if only_for_model and model_key != only_for_model:
continue # Avoid overwriting data of the other models (useful for refreshing a just-registered model)
model.set_is_supported(
model_key in role_models[ROLE_SUPPORTED_MODELS])
model.set_is_hidden(model_key in role_models[ROLE_HIDDEN_MODELS])
model.set_is_checked(model_key in role_models[ROLE_CHECKED_MODELS])
# First attempt to get ili2db parameters from role, otherwise from model config
model_ili2db_params = ili2db_params.get(
model_key, dict()) or model.get_default_ili2db_params()
model.set_ili2db_params(model_ili2db_params)
if model_ili2db_params:
self.logger.debug(
__name__,
"Model ili2db params are: {}".format(model_ili2db_params))
self.logger.debug(
__name__, "Supported models for active role '{}': {}".format(
role_key, role_models[ROLE_SUPPORTED_MODELS]))
def refresh_models_for_role(self):
role_key = RoleRegistry().get_active_role()
role_models = RoleRegistry().get_role_models(role_key)
# ili2db params may come from the model config itself or overwritten by the current user.
# It the user does not have such config, we grab it from MODEL_CONFIG.
ili2db_params = role_models[
ROLE_MODEL_ILI2DB_PARAMETERS] if ROLE_MODEL_ILI2DB_PARAMETERS in role_models else dict(
)
for model_key, model in self.__models.items():
model.set_is_supported(
model_key in role_models[ROLE_SUPPORTED_MODELS])
model.set_is_hidden(model_key in role_models[ROLE_HIDDEN_MODELS])
model.set_is_checked(model_key in role_models[ROLE_CHECKED_MODELS])
if model_key in ili2db_params and ili2db_params[model_key]:
model_ili2db_params = ili2db_params[model_key]
else:
model_ili2db_params = self.__get_model_iili2db_params_from_config(
model_key)
if model_ili2db_params:
self.logger.debug(
__name__,
"Model ili2db params are: {}".format(model_ili2db_params))
model.set_ili2db_params(model_ili2db_params)
self.logger.debug(
__name__, "Supported models for role '{}': {}".format(
role_key, role_models[ROLE_SUPPORTED_MODELS]))
def _get_gui_config(self, role_key):
"""
Get a basic GUI config (still unfiltered).
:param role_key: Active role key to whom we will ask for its GUI config. Normally, it should be the active one.
:return: Dictionary in the form of a gui_config dict (still unfiltered).
"""
if self._test_conn_result:
self.logger.info(__name__,
"Using template gui_config from the role.")
return RoleRegistry().get_role_gui_config(role_key)
else:
default_gui = RoleRegistry().get_role_gui_config(
role_key, DEFAULT_GUI)
if default_gui:
self.logger.info(
__name__,
"Using default gui_config (minimal) from the role.")
return default_gui
else:
self.logger.info(
__name__,
"Using gui_config from the default GUI (minimal).")
return GUI_Config().get_gui_dict(
DEFAULT_GUI
) # Use a default gui config given by the plugin
def _get_filtered_gui_config(self):
"""
Rebuilds a gui_config dict removing not allowed actions.
:return: Dictionary in the form of a gui_config dict, but only with allowed actions for the role_key passed.
"""
role_key = RoleRegistry().get_active_role()
self.logger.info(
__name__,
"Active role: {}".format(RoleRegistry().get_role_name(role_key)))
gui_config = self._get_gui_config(role_key)
# self.logger.debug(__name__, "Filtered gui_config: {}".format(gui_config))
role_actions = self._get_role_actions(role_key)
model_actions = self._get_model_actions(
) if self._test_conn_result else list()
# If you want to take models into account, combine role_actions and model_actions as you like, and store the
# result in allowed_actions.
#
# Here we define how to deal with actions, role permissions and models present
# We decided to prefer always the rol's actions. Like this (R: Role, M: Model, Res: Result):
# R M Res
# V V V
# V F V
# F V F
# F F F
#
# Therefore:
allowed_actions = role_actions # It's safe to make use of this list, no need to copy it, as it's a sum of lists
self.logger.debug(
__name__,
"Allowed actions for role '{}': {}".format(role_key,
allowed_actions))
# Now, use only allowed actions and remove other actions from gui_config
filtered_gui_config = dict()
for k, v in gui_config.items():
if k == MAIN_MENU or k == TOOLBAR:
for menu_def in v:
actions = self._get_filtered_actions(
menu_def[ACTIONS], allowed_actions)
if actions:
menu_def[ACTIONS] = actions
if not k in filtered_gui_config:
filtered_gui_config[k] = [menu_def]
else:
filtered_gui_config[k].append(menu_def)
return filtered_gui_config
def __init__(self, parent):
QDialog.__init__(self, parent)
self.setupUi(self)
self.logger = Logger()
self.help_strings = HelpStrings()
#self.txt_help_page.setHtml(self.help_strings.DLG_WELCOME_SCREEN)
#self.txt_help_page.anchorClicked.connect(self.save_template)
self.finished.connect(self.finish_dialog)
self.buttonBox.helpRequested.connect(self.show_help)
self.gbx_layout = QVBoxLayout()
self.roles = RoleRegistry()
self.dict_roles = self.roles.get_roles_info()
checked = False
active_role = self.roles.get_active_role()
# Initialize radio buttons
for k,v in self.dict_roles.items():
radio = QRadioButton(v)
if not checked:
if k == active_role:
radio.setChecked(True)
checked = True
self.show_description(self.roles.get_role_description(k), checked) # Initialize help page
radio.toggled.connect(partial(self.show_description, self.roles.get_role_description(k)))
self.gbx_layout.addWidget(radio)
self.gbx_options.setLayout(self.gbx_layout)
def _get_role_actions(self, role_key):
"""
Get actions a given role has access to.
:param role_key: Role key.
:return: List of actions a role has access to.
"""
return RoleRegistry().get_role_actions(role_key)
def __init__(self):
self.logger = Logger()
self.__quality_rules_data = QualityRuleConfig.get_quality_rules_config(
)
self.__translated_strings = TranslatableConfigStrings(
).get_translatable_config_strings()
self._quality_rule_groups = dict()
self.__quality_rules = dict()
self.role_registry = RoleRegistry()
self._initialize_quality_rule_manager()
def get_qrs_per_role_and_models(self, db, as_dict=True):
"""
:param as_dict: Boolean. If False, the result is returned as a list or rule keys
"""
qrs = dict()
role_registry = RoleRegistry()
role_qrs = role_registry.get_role_quality_rules(role_registry.get_active_role())
if role_qrs == ALL_QUALITY_RULES:
role_qrs = self.__quality_rules
if role_qrs:
db_models = db.get_models()
model_registry = LADMColModelRegistry()
for qr in role_qrs:
# First check if the role QR is registered
if qr in self.__quality_rules:
# Then check if the models required by the QR are in the DB
req_models = self.__quality_rules[qr].models()
num_models = len(req_models)
all_models_found = True
if num_models: # We don't check models if a QR has no required models (e.g., iliValidator)
for req_model in req_models:
model = model_registry.model(req_model)
model_key = model.full_name()
if model_key and model_key not in db_models:
all_models_found = False
self.logger.debug(__name__,
"Model '{}' not found in the DB. QR '{}' cannot be listed.".format(
model_key, qr
))
break
if all_models_found:
qrs[qr] = self.__quality_rules[qr]
return qrs if as_dict else list(qrs.keys())
def _get_gui_config(self, role_key):
"""
Get a basic GUI config (still unfiltered).
:param role_key: Active role key to whom we will ask for its GUI config. Normally, it should be the active one.
:return: Dictionary in the form of a gui_config dict (still unfiltered).
"""
gui_type = DEFAULT_GUI # If test_connection is False, we use a default gui config
if self._test_conn_result:
gui_config = RoleRegistry().get_role_gui_config(role_key)
if gui_config:
self.logger.info(__name__, "Using gui_config from the role.")
return gui_config
else:
self.logger.info(__name__,
"Using gui_config from the template.")
gui_type = TEMPLATE_GUI
if gui_type == DEFAULT_GUI:
self.logger.info(
__name__, "Using gui_config from the default GUI (minimal).")
return GUI_Config().get_gui_dict(gui_type)
def login(self, user, password):
msg = ""
should_emit_role_changed = False
st_config = TransitionalSystemConfig()
payload = st_config.ST_LOGIN_SERVICE_PAYLOAD.format(user, password)
headers = {
'Content-Type': "application/x-www-form-urlencoded",
'Authorization': st_config.ST_LOGIN_AUTHORIZATION_CLIENT,
'Accept': "*/*",
'Cache-Control': "no-cache",
'Accept-Encoding': "gzip, deflate",
'Connection': "keep-alive",
'cache-control': "no-cache"
}
s = requests.Session()
s.mount(st_config.ST_LOGIN_SERVICE_URL, HTTPAdapter(max_retries=0))
try:
response = s.request("POST", st_config.ST_LOGIN_SERVICE_URL, data=payload, headers=headers)
except requests.ConnectionError as e:
msg = QCoreApplication.translate("STSession", "There was an error accessing the login service. Details: {}").format(e)
self.logger.warning(__name__, msg)
return False, msg, False
status_OK = response.status_code == 200
self.logger.info(__name__, "Login response status code: {}".format(response.status_code))
if status_OK:
logged_data = json.loads(response.text)
# Check if ST role is recognized by LADM-COL Assistant. Otherwise, do not login.
st_role = logged_data['roles'][0]['id']
if st_role not in st_config.ROLE_MAPPING:
return status_OK, \
QCoreApplication.translate("STSession",
"The user cannot log-in into the Transitional System because the '{}' ST role has no tasks assigned in LADM-COL Assistant!".format(logged_data['roles'][0]['name'])), \
False
msg = QCoreApplication.translate("STSession", "User logged in successfully in the Transitional System!")
self.__logged_user = STLoggedUser("{} {}".format(logged_data['first_name'],
logged_data['last_name']),
logged_data['email'],
logged_data['roles'][0]['name'],
logged_data['access_token'])
QSettings().setValue(self.TOKEN_KEY, logged_data['access_token']) # Register (login) the user
# self.login_status_changed.emit(True) Don't emit now, a GUI refresh comes, so updates will be lost
self.logger.info(__name__, msg)
# Make LADM-COL Assistant's current role correspond to the logged in user role in ST
if st_config.ROLE_MAPPING[st_role] != RoleRegistry().get_active_role():
RoleRegistry().set_active_role(st_config.ROLE_MAPPING[st_role], emit_signal=False)
should_emit_role_changed = True # Safer to let the dialog deal with that SIGNAL (refreshes the GUI!)
else:
if response.status_code == 400:
msg = QCoreApplication.translate("STSession",
"Wrong user name or password, change credentials and try again.")
elif response.status_code == 500:
msg = QCoreApplication.translate("STSession", "There is an error in the login server!")
elif response.status_code > 500 and response.status_code < 600:
msg = st_config.ST_STATUS_GT_500_MSG
self.logger.warning(__name__, st_config.ST_STATUS_GT_500_MSG)
elif response.status_code == 401:
msg = QCoreApplication.translate("STSession", "Unauthorized client! The server won't allow requests from this client.")
self.logger.warning(__name__, msg)
return status_OK, msg, should_emit_role_changed
def show_welcome_screen(self):
return not RoleRegistry().active_role_already_set()
def __init__(self, conn_manager=None, context=None, parent=None):
QDialog.__init__(self, parent)
self.setupUi(self)
self.parent = parent
self.logger = Logger()
self.conn_manager = conn_manager
self.app = AppInterface()
self.sbx_tolerance.setMaximum(TOLERANCE_MAX_VALUE)
self._valid_document_repository = False # Needs to be True if users want to enable doc repo (using test button)
context = context if context else SettingsContext()
self.db_source = context.db_source # default db source is COLLECTED_DB_SOURCE
self._required_models = context.required_models
self._tab_pages_list = context.tab_pages_list
self._blocking_mode = context.blocking_mode # Whether the dialog can only be accepted on valid DB connections or not
self._action_type = context.action_type # By default "config"
self.setWindowTitle(context.title)
self._db = None
self.init_db_engine = None
self.dbs_supported = ConfigDBsSupported()
self._open_dlg_import_schema = False # After accepting, if non-valid DB is configured, we can go to import schema
self.online_models_radio_button.setEnabled(
False) # This option is disabled until we have online models back!
self.online_models_radio_button.setChecked(True)
self.online_models_radio_button.toggled.connect(
self.model_provider_toggle)
self.custom_model_directories_line_edit.setText("")
self.custom_models_dir_button.clicked.connect(
self.show_custom_model_dir)
self.custom_model_directories_line_edit.setVisible(False)
self.custom_models_dir_button.setVisible(False)
# Set connections
self.buttonBox.accepted.disconnect()
self.buttonBox.accepted.connect(self.accepted)
self.buttonBox.helpRequested.connect(self.show_help)
self.finished.connect(self.finished_slot)
self.btn_test_connection.clicked.connect(self.test_connection)
self.btn_test_ladm_col_structure.clicked.connect(
self.test_ladm_col_structure)
self.btn_test_service.clicked.connect(self.test_service)
self.btn_test_service_transitional_system.clicked.connect(
self.test_service_transitional_system)
self.txt_service_endpoint.textEdited.connect(
self.source_service_endpoint_changed) # For manual changes only
self.btn_default_value_sources.clicked.connect(
self.set_default_value_source_service)
self.btn_default_value_transitional_system.clicked.connect(
self.set_default_value_transitional_system_service)
self.chk_use_roads.toggled.connect(self.update_images_state)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.cbo_db_engine.clear()
self._lst_db = self.dbs_supported.get_db_factories()
self._lst_panel = dict()
for key, value in self._lst_db.items():
self.cbo_db_engine.addItem(value.get_name(), key)
self._lst_panel[key] = value.get_config_panel(self)
self._lst_panel[key].notify_message_requested.connect(
self.show_message)
self.db_layout.addWidget(self._lst_panel[key])
self.db_engine_changed()
# Trigger some default behaviours
self.restore_db_source_settings(
) # restore settings with default db source
self.restore_settings()
self.roles = RoleRegistry()
self.load_roles()
self.cbo_db_engine.currentIndexChanged.connect(self.db_engine_changed)
self.rejected.connect(self.close_dialog)
self._update_tabs()
if context.tip:
self.show_tip(context.tip)
def refresh_mapping_for_role(self):
for model_key in RoleRegistry().get_active_role_supported_models():
if model_key in DB_MAPPING_CONFIG:
self.register_db_mapping(DB_MAPPING_CONFIG[model_key])