class RightOfWayManager:
def __init__(self, db, layers, editing_layer):
self._db = db
self.__layers = layers
self.__translatable_config_strings = TranslatableConfigStrings()
self.width_line = 1.0
self._editing_layer = editing_layer
self.app = None
def finish_feature_creation(self, layerId, features):
fid = features[0].id()
is_valid = False
feature_tid = None
if self._editing_layer.getFeature(fid).isValid():
is_valid = True
feature_tid = self._editing_layer.getFeature(fid)[self._db.names.T_ID_F]
return FinishFeatureCreationArgs(is_valid, feature_tid)
def get_memory_line_layer(self, base_layer):
translated_strings = self.__translatable_config_strings.get_translatable_config_strings()
# Add Memory line layer
temporal_layer = QgsVectorLayer(
"MultiLineString?crs={}".format(get_crs_authid(base_layer.sourceCrs())),
translated_strings[RIGHT_OF_WAY_LINE_LAYER], "memory")
return temporal_layer
def get_feature_with_buffer_right_of_way(self, tmp_layer, layer):
params = {'INPUT': tmp_layer,
'DISTANCE': self.width_line,
'SEGMENTS': 5,
'END_CAP_STYLE': 1, # Flat
'JOIN_STYLE': 2,
'MITER_LIMIT': 2,
'DISSOLVE': False,
'OUTPUT': 'memory:'}
buffered_right_of_way_layer = processing.run("native:buffer", params)['OUTPUT']
buffer_geometry = buffered_right_of_way_layer.getFeature(1).geometry()
feature = QgsVectorLayerUtils().createFeature(layer, buffer_geometry)
tmp_layer.commitChanges()
return feature
def add_tmp_feature_to_layer(self, layer, tmp_feature):
# Add temporal geometry create
if not layer.isEditable():
layer.startEditing()
self.app.core.suppress_form(layer, True)
layer.addFeature(tmp_feature)
def get_quality_error_group_names():
root = QgsProject.instance().layerTreeRoot()
prefix = TranslatableConfigStrings.get_translatable_config_strings(
)[ERROR_LAYER_GROUP_PREFIX]
error_group_names = list()
for group in root.findGroups(False):
if group.name().startswith(prefix):
error_group_names.append(group.name())
return error_group_names
def get_quality_error_group(timestamp, create_if_non_existent=True):
root = QgsProject.instance().layerTreeRoot()
prefix = TranslatableConfigStrings.get_translatable_config_strings(
)[ERROR_LAYER_GROUP_PREFIX]
group_name = "{} {}".format(prefix, timestamp)
group = root.findGroup(group_name)
if group is None and create_if_non_existent:
group = root.insertGroup(0, group_name)
ilg = qgis.utils.plugins['InvisibleLayersAndGroups']
ilg.hideGroup(group)
group.setExpanded(False)
return group
def get_indicators_config(self, node_name, node_type):
"""
Gets the configuration of layer tree node indicators. Each node could have several indicators.
:param node_name: Layer tree node name
:param node_type: QgsLayerTreeNode.NodeType
:return: List of indicators data. Each indicator config data is a dict, which has these mandatory keys:
INDICATOR_TOOLTIP,
INDICATOR_ICON,
INDICATOR_SLOT
"""
indicators_config = []
translated_strings = TranslatableConfigStrings.get_translatable_config_strings(
)
if node_type == QgsLayerTreeNode.NodeGroup:
if node_name == translated_strings[ERROR_LAYER_GROUP]:
indicators_config = [{
INDICATOR_TOOLTIP:
QCoreApplication.translate(
"LayerTreeIndicatorConfig",
"<b>Export</b><br>Export quality errors to GeoPackage"
),
INDICATOR_ICON:
QIcon(":/Asistente-LADM-COL/resources/images/save.svg"),
INDICATOR_SLOT:
self._slot_caller.export_error_group
}, {
INDICATOR_TOOLTIP:
QCoreApplication.translate(
"LayerTreeIndicatorConfig",
"<b>Export</b><br>Export quality errors to PDF"),
INDICATOR_ICON:
QIcon(":/Asistente-LADM-COL/resources/images/pdf.svg"),
INDICATOR_SLOT:
self._slot_caller.show_log_quality_dialog
}]
elif node_type == QgsLayerTreeNode.NodeLayer:
pass
return indicators_config
def get_error_layers_group(self):
"""
Get the topology errors group. If it exists but is placed in another
position rather than the top, it moves the group to the top.
"""
root = QgsProject.instance().layerTreeRoot()
translated_strings = TranslatableConfigStrings.get_translatable_config_strings(
)
group = root.findGroup(translated_strings[ERROR_LAYER_GROUP])
if group is None:
group = root.insertGroup(0, translated_strings[ERROR_LAYER_GROUP])
self.add_indicators_requested.emit(
translated_strings[ERROR_LAYER_GROUP],
QgsLayerTreeNode.NodeGroup)
elif not self.iface.layerTreeView().layerTreeModel().node2index(
group).row() == 0 or type(group.parent()) is QgsLayerTreeGroup:
group_clone = group.clone()
root.insertChildNode(0, group_clone)
parent = group.parent()
parent.removeChildNode(group)
group = group_clone
return group
class QgisModelBakerUtils(QObject):
def __init__(self):
QObject.__init__(self)
self.logger = Logger()
from asistente_ladm_col.config.config_db_supported import ConfigDBsSupported
self._dbs_supported = ConfigDBsSupported()
self.translatable_config_strings = TranslatableConfigStrings()
def get_generator(self, db):
if 'QgisModelBaker' in qgis.utils.plugins:
tool = self._dbs_supported.get_db_factory(
db.engine).get_model_baker_db_ili_mode()
QgisModelBaker = qgis.utils.plugins["QgisModelBaker"]
generator = QgisModelBaker.get_generator()(
tool, db.uri, "smart2", db.schema, pg_estimated_metadata=False)
return generator
else:
self.logger.critical(
__name__,
QCoreApplication.translate(
"AsistenteLADMCOLPlugin",
"The QGIS Model Baker plugin is a prerequisite, install it before using LADM-COL Assistant."
))
return None
def get_model_baker_db_connection(self, db):
generator = self.get_generator(db)
if generator is not None:
return generator._db_connector
return None
def load_layers(self, db, layer_list):
"""
Load a selected list of layers from qgis model baker.
This call should configure relations and bag of enums
between layers being loaded, but not when a layer already
loaded has a relation or is part of a bag of enum. For
that case, we use a cached set of relations and bags of
enums that we get only once per session and configure in
the Asistente LADM-COL.
"""
translated_strings = self.translatable_config_strings.get_translatable_config_strings(
)
if 'QgisModelBaker' in qgis.utils.plugins:
QgisModelBaker = qgis.utils.plugins["QgisModelBaker"]
tool = self._dbs_supported.get_db_factory(
db.engine).get_model_baker_db_ili_mode()
generator = QgisModelBaker.get_generator()(
tool, db.uri, "smart2", db.schema, pg_estimated_metadata=False)
layers = generator.layers(layer_list)
relations, bags_of_enum = generator.relations(layers, layer_list)
legend = generator.legend(
layers,
ignore_node_names=[translated_strings[ERROR_LAYER_GROUP]])
QgisModelBaker.create_project(layers,
relations,
bags_of_enum,
legend,
auto_transaction=False)
else:
self.logger.critical(
__name__,
QCoreApplication.translate(
"AsistenteLADMCOLPlugin",
"The QGIS Model Baker plugin is a prerequisite, install it before using LADM-COL Assistant."
))
def get_required_layers_without_load(self, layer_list, db):
"""
Gets a list of layers from a list of layer names using QGIS Model Baker.
Layers are register in QgsProject, but not loaded to the canvas!
:param layer_list: list of layers names (e.g., ['lc_terreno', 'lc_lindero'])
:param db: db connection
:return: list of QgsVectorLayers registered in the project
"""
layers = list()
if 'QgisModelBaker' in qgis.utils.plugins:
QgisModelBaker = qgis.utils.plugins["QgisModelBaker"]
tool = self._dbs_supported.get_db_factory(
db.engine).get_model_baker_db_ili_mode()
generator = QgisModelBaker.get_generator()(
tool, db.uri, "smart2", db.schema, pg_estimated_metadata=False)
model_baker_layers = generator.layers(layer_list)
for model_baker_layer in model_baker_layers:
layer = model_baker_layer.create(
) # Convert Model Baker layer to QGIS layer
QgsProject.instance().addMapLayer(
layer, False) # Do not load it to canvas
layers.append(layer)
else:
self.logger.critical(
__name__,
QCoreApplication.translate(
"AsistenteLADMCOLPlugin",
"The QGIS Model Baker plugin is a prerequisite, install it before using LADM-COL Assistant."
))
return layers
def get_layers_and_relations_info(self, db):
"""
Called once per session, this is used to get information
of all relations and bags of enums in the DB and cache it
in the Asistente LADM-COL.
"""
if 'QgisModelBaker' in qgis.utils.plugins:
generator = self.get_generator(db)
layers = generator.get_tables_info_without_ignored_tables()
relations = [
relation for relation in generator.get_relations_info()
]
self.logger.debug(
__name__,
"Relationships before filter: {}".format(len(relations)))
self.filter_relations(relations)
self.logger.debug(
__name__,
"Relationships after filter: {}".format(len(relations)))
return (layers, relations, {})
else:
self.logger.critical(
__name__,
QCoreApplication.translate(
"AsistenteLADMCOLPlugin",
"The QGIS Model Baker plugin is a prerequisite, install it before using LADM-COL Assistant."
))
return (list(), list(), dict())
def filter_relations(self, relations):
"""
Modifies the input list of relations, removing elements that meet a condition.
:param relations: List of a dict of relations.
:return: Nothing, changes the input list of relations.
"""
to_delete = list()
for relation in relations:
if relation[QueryNames.REFERENCING_FIELD].startswith(
'uej2_') or relation[
QueryNames.REFERENCING_FIELD].startswith('ue_'):
to_delete.append(relation)
for idx in to_delete:
relations.remove(idx)
def get_tables_info_without_ignored_tables(self, db):
if 'QgisModelBaker' in qgis.utils.plugins:
generator = self.get_generator(db)
return generator.get_tables_info_without_ignored_tables()
else:
self.logger.critical(
__name__,
QCoreApplication.translate(
"AsistenteLADMCOLPlugin",
"The QGIS Model Baker plugin is a prerequisite, install it before using LADM-COL Assistant."
))
def get_first_index_for_layer_type(
self, layer_type, group=QgsProject.instance().layerTreeRoot()):
if 'QgisModelBaker' in qgis.utils.plugins:
import QgisModelBaker
return QgisModelBaker.utils.qgis_utils.get_first_index_for_layer_type(
layer_type, group)
return None
@staticmethod
def get_suggested_index_for_layer(layer, group):
if 'QgisModelBaker' in qgis.utils.plugins:
import QgisModelBaker
return QgisModelBaker.utils.qgis_utils.get_suggested_index_for_layer(
layer, group)
return None
class QualityDialog(QDialog, DIALOG_UI):
def __init__(self, db, qgis_utils, quality, parent=None):
QDialog.__init__(self, parent)
self.setupUi(self)
self._db = db
self.qgis_utils = qgis_utils
self.quality = quality
self.names = self._db.names
self.translatable_config_strings = TranslatableConfigStrings()
self.trw_quality_rules.setItemsExpandable(False)
self.trw_quality_rules.itemSelectionChanged.connect(
self.validate_selection_rules)
self.trw_quality_rules.itemSelectionChanged.emit()
# Set connections
self.buttonBox.accepted.connect(self.accepted)
self.buttonBox.rejected.connect(self.rejected)
self.buttonBox.helpRequested.connect(self.show_help)
self.btn_select_all.clicked.connect(self.select_all)
self.btn_clear_selection.clicked.connect(self.clear_selection)
translated_strings = self.translatable_config_strings.get_translatable_config_strings(
)
self.items_dict = collections.OrderedDict()
self.items_dict[QCoreApplication.translate(
"QualityDialog", "Rules for Points"
)] = {
'icon':
'points',
'rules': [{
'id':
'check_overlaps_in_boundary_points',
'text':
translated_strings[CHECK_OVERLAPS_IN_BOUNDARY_POINTS]
}, {
'id':
'check_overlaps_in_control_points',
'text':
translated_strings[CHECK_OVERLAPS_IN_CONTROL_POINTS]
}, {
'id':
'check_boundary_points_covered_by_boundary_nodes',
'text':
translated_strings[
CHECK_BOUNDARY_POINTS_COVERED_BY_BOUNDARY_NODES]
}, {
'id':
'check_boundary_points_covered_by_plot_nodes',
'text':
translated_strings[CHECK_BOUNDARY_POINTS_COVERED_BY_PLOT_NODES]
}]
}
self.items_dict[QCoreApplication.translate(
"QualityDialog", "Rules for Lines")] = {
'icon':
'lines',
'rules': [{
'id':
'check_overlaps_in_boundaries',
'text':
translated_strings[CHECK_OVERLAPS_IN_BOUNDARIES]
}, {
'id':
'check_boundaries_are_not_split',
'text':
translated_strings[CHECK_BOUNDARIES_ARE_NOT_SPLIT]
}, {
'id':
'check_boundaries_covered_by_plots',
'text':
translated_strings[CHECK_BOUNDARIES_COVERED_BY_PLOTS]
}, {
'id':
'check_boundary_nodes_covered_by_boundary_points',
'text':
translated_strings[
CHECK_BOUNDARY_NODES_COVERED_BY_BOUNDARY_POINTS]
}, {
'id':
'check_dangles_in_boundaries',
'text':
translated_strings[CHECK_DANGLES_IN_BOUNDARIES]
}]
}
self.items_dict[QCoreApplication.translate(
"QualityDialog", "Rules for Polygons"
)] = {
'icon':
'polygons',
'rules': [
{
'id': 'check_overlaps_in_plots',
'text': translated_strings[CHECK_OVERLAPS_IN_PLOTS]
},
{
'id': 'check_overlaps_in_buildings',
'text': translated_strings[CHECK_OVERLAPS_IN_BUILDINGS]
},
{
'id': 'check_overlaps_in_rights_of_way',
'text': translated_strings[CHECK_OVERLAPS_IN_RIGHTS_OF_WAY]
},
{
'id': 'check_plots_covered_by_boundaries',
'text':
translated_strings[CHECK_PLOTS_COVERED_BY_BOUNDARIES]
#}, {
# 'id': 'check_missing_survey_points_in_buildings',
# 'text': QCoreApplication.translate("QualityDialog", "Buildings nodes should be covered by Survey Points")
},
{
'id':
'check_right_of_way_overlaps_buildings',
'text':
translated_strings[CHECK_RIGHT_OF_WAY_OVERLAPS_BUILDINGS]
},
{
'id': 'check_gaps_in_plots',
'text': translated_strings[CHECK_GAPS_IN_PLOTS]
},
{
'id': 'check_multipart_in_right_of_way',
'text': translated_strings[CHECK_MULTIPART_IN_RIGHT_OF_WAY]
},
{
'id':
'check_plot_nodes_covered_by_boundary_points',
'text':
translated_strings[
CHECK_PLOT_NODES_COVERED_BY_BOUNDARY_POINTS]
},
{
'id': 'check_buildings_should_be_within_plots',
'text': translated_strings[CHECK_BUILDING_WITHIN_PLOTS]
},
{
'id': 'check_building_units_should_be_within_plots',
'text':
translated_strings[CHECK_BUILDING_UNIT_WITHIN_PLOTS]
}
]
}
self.items_dict[QCoreApplication.translate(
"QualityDialog", "Logic consistency rules")] = {
'icon':
'tables',
'rules': [{
'id':
'check_parcel_right_relationship',
'text':
translated_strings[CHECK_PARCEL_RIGHT_RELATIONSHIP]
}, {
'id':
'find_duplicate_records_in_a_table',
'text':
translated_strings[FIND_DUPLICATE_RECORDS_IN_A_TABLE]
}, {
'id':
'check_fraction_sum_for_party_groups',
'text':
translated_strings[CHECK_FRACTION_SUM_FOR_PARTY_GROUPS]
}, {
'id':
'check_department_code_has_two_numerical_characters',
'text':
translated_strings[
CHECK_DEPARMENT_CODE_HAS_TWO_NUMERICAL_CHARACTERS]
}, {
'id':
'check_municipality_code_has_three_numerical_characters',
'text':
translated_strings[
CHECK_MUNICIPALITY_CODE_HAS_THREE_NUMERICAL_CHARACTERS]
}, {
'id':
'check_parcel_number_has_30_numerical_characters',
'text':
translated_strings[
CHECK_PARCEL_NUMBER_HAS_30_NUMERICAL_CHARACTERS]
}, {
'id':
'check_parcel_number_before_has_20_numerical_characters',
'text':
translated_strings[
CHECK_PARCEL_NUMBER_BEFORE_HAS_20_NUMERICAL_CHARACTERS]
}, {
'id':
'check_col_party_natural_type',
'text':
translated_strings[CHECK_COL_PARTY_NATURAL_TYPE]
}, {
'id':
'check_col_party_legal_type',
'text':
translated_strings[CHECK_COL_PARTY_LEGAL_TYPE]
}, {
'id':
'check_parcel_type_and_22_position_of_parcel_number',
'text':
translated_strings[
CHECK_PARCEL_TYPE_AND_22_POSITON_OF_PARCEL_NUMBER]
}, {
'id': 'check_uebaunit_parcel',
'text': translated_strings[CHECK_UEBAUNIT_PARCEL]
}]
}
self.load_items()
def validate_selection_rules(self):
# At least one quality rule must have been selected
self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(
bool(self.trw_quality_rules.selectedItems()))
def load_items(self):
self.trw_quality_rules.setUpdatesEnabled(
False) # Don't render until we're ready
self.trw_quality_rules.clear()
font = QFont()
font.setBold(True)
for group, items in self.items_dict.items():
children = []
group_item = QTreeWidgetItem([group])
group_item.setData(0, Qt.BackgroundRole,
QBrush(QColor(219, 219, 219, 255)))
group_item.setData(0, Qt.FontRole, font)
icon = QIcon(":/Asistente-LADM_COL/resources/images/{}.png".format(
items['icon']))
group_item.setData(0, Qt.DecorationRole, icon)
for rule in items['rules']:
rule_item = QTreeWidgetItem([rule['text']])
rule_item.setData(0, Qt.UserRole, rule['id'])
children.append(rule_item)
group_item.addChildren(children)
self.trw_quality_rules.addTopLevelItem(group_item)
# Make group items non selectable and expanded
for i in range(self.trw_quality_rules.topLevelItemCount()):
self.trw_quality_rules.topLevelItem(i).setFlags(
Qt.ItemIsEnabled) # Not selectable
self.trw_quality_rules.topLevelItem(i).setExpanded(True)
self.trw_quality_rules.setUpdatesEnabled(True) # Now render!
def accepted(self):
# we erase the group error layer every time it runs because we assume that data set changes.
self.qgis_utils.remove_error_group_requested.emit()
self.quality.initialize_log_dialog_quality()
selected_count = len(self.trw_quality_rules.selectedItems())
if selected_count > 0:
self.quality.set_count_topology_rules(selected_count)
translated_strings = self.translatable_config_strings.get_translatable_config_strings(
)
iterator = QTreeWidgetItemIterator(self.trw_quality_rules,
QTreeWidgetItemIterator.Selectable)
while iterator.value():
item = iterator.value()
if item.isSelected():
id = item.data(0, Qt.UserRole)
rule_name = item.text(0)
# NOTE: Do not remove the named parameters, this is needed for making a decorator that thinks they are
# optional happy!
if id == 'check_overlaps_in_boundary_points':
self.quality.check_overlapping_points(
self._db,
point_layer_name=self.names.OP_BOUNDARY_POINT_T,
rule_name=rule_name,
translated_strings=translated_strings)
elif id == 'check_overlaps_in_control_points':
self.quality.check_overlapping_points(
self._db,
point_layer_name=self.names.OP_CONTROL_POINT_T,
rule_name=rule_name,
translated_strings=translated_strings)
elif id == 'check_boundary_points_covered_by_boundary_nodes':
self.quality.check_boundary_points_covered_by_boundary_nodes(
self._db,
rule_name=rule_name,
translated_strings=translated_strings)
elif id == 'check_boundary_points_covered_by_plot_nodes':
self.quality.check_boundary_points_covered_by_plot_nodes(
self._db,
rule_name=rule_name,
translated_strings=translated_strings)
elif id == 'check_overlaps_in_boundaries':
self.quality.check_overlaps_in_boundaries(
self._db,
rule_name=rule_name,
translated_strings=translated_strings)
elif id == 'check_boundaries_are_not_split':
self.quality.check_boundaries_are_not_split(
self._db,
rule_name=rule_name,
translated_strings=translated_strings)
elif id == 'check_boundaries_covered_by_plots':
self.quality.check_boundaries_covered_by_plots(
self._db,
rule_name=rule_name,
translated_strings=translated_strings)
elif id == 'check_boundary_nodes_covered_by_boundary_points':
self.quality.check_boundary_nodes_covered_by_boundary_points(
self._db,
rule_name=rule_name,
translated_strings=translated_strings)
elif id == 'check_dangles_in_boundaries':
self.quality.check_dangles_in_boundaries(
self._db,
rule_name=rule_name,
translated_strings=translated_strings)
elif id == 'check_overlaps_in_plots':
self.quality.check_overlapping_polygons(
self._db,
polygon_layer_name=self.names.OP_PLOT_T,
rule_name=rule_name,
translated_strings=translated_strings)
elif id == 'check_overlaps_in_buildings':
self.quality.check_overlapping_polygons(
self._db,
polygon_layer_name=self.names.OP_BUILDING_T,
rule_name=rule_name,
translated_strings=translated_strings)
elif id == 'check_overlaps_in_rights_of_way':
self.quality.check_overlapping_polygons(
self._db,
polygon_layer_name=self.names.OP_RIGHT_OF_WAY_T,
rule_name=rule_name,
translated_strings=translated_strings)
elif id == 'check_plots_covered_by_boundaries':
self.quality.check_plots_covered_by_boundaries(
self._db,
rule_name=rule_name,
translated_strings=translated_strings)
#elif id == 'check_missing_survey_points_in_buildings':
# self.quality.check_missing_survey_points_in_buildings(self._db)
elif id == 'check_right_of_way_overlaps_buildings':
self.quality.check_right_of_way_overlaps_buildings(
self._db,
rule_name=rule_name,
translated_strings=translated_strings)
elif id == 'check_gaps_in_plots':
self.quality.check_gaps_in_plots(
self._db,
rule_name=rule_name,
translated_strings=translated_strings)
elif id == 'check_multipart_in_right_of_way':
self.quality.check_multiparts_in_right_of_way(
self._db,
rule_name=rule_name,
translated_strings=translated_strings)
elif id == 'check_plot_nodes_covered_by_boundary_points':
self.quality.check_plot_nodes_covered_by_boundary_points(
self._db,
rule_name=rule_name,
translated_strings=translated_strings)
elif id == 'check_buildings_should_be_within_plots':
self.quality.check_building_within_plots(
self._db,
rule_name=rule_name,
translated_strings=translated_strings)
elif id == 'check_building_units_should_be_within_plots':
self.quality.check_building_unit_within_plots(
self._db,
rule_name=rule_name,
translated_strings=translated_strings)
elif id == 'check_parcel_right_relationship':
self.quality.check_parcel_right_relationship(
self._db,
rule_name=rule_name,
translated_strings=translated_strings)
elif id == 'find_duplicate_records_in_a_table':
self.quality.find_duplicate_records_in_a_table(
self._db, rule_name=rule_name)
elif id == 'check_fraction_sum_for_party_groups':
self.quality.check_fraction_sum_for_party_groups(
self._db, rule_name=rule_name)
elif id == 'check_department_code_has_two_numerical_characters':
self.quality.basic_logic_validations(
self._db,
rule='DEPARTMENT_CODE_VALIDATION',
rule_name=rule_name)
elif id == 'check_municipality_code_has_three_numerical_characters':
self.quality.basic_logic_validations(
self._db,
rule='MUNICIPALITY_CODE_VALIDATION',
rule_name=rule_name)
elif id == 'check_parcel_number_has_30_numerical_characters':
self.quality.basic_logic_validations(
self._db,
rule='PARCEL_NUMBER_VALIDATION',
rule_name=rule_name)
elif id == 'check_parcel_number_before_has_20_numerical_characters':
self.quality.basic_logic_validations(
self._db,
rule='PARCEL_NUMBER_BEFORE_VALIDATION',
rule_name=rule_name)
elif id == 'check_col_party_natural_type':
self.quality.advanced_logic_validations(
self._db,
rule='COL_PARTY_TYPE_NATURAL_VALIDATION',
rule_name=rule_name)
elif id == 'check_col_party_legal_type':
self.quality.advanced_logic_validations(
self._db,
rule='COL_PARTY_TYPE_NO_NATURAL_VALIDATION',
rule_name=rule_name)
elif id == 'check_parcel_type_and_22_position_of_parcel_number':
self.quality.advanced_logic_validations(
self._db,
rule=
'PARCEL_TYPE_AND_22_POSITION_OF_PARCEL_NUMBER_VALIDATION',
rule_name=rule_name)
elif id == 'check_uebaunit_parcel':
self.quality.advanced_logic_validations(
self._db,
rule='UEBAUNIT_PARCEL_VALIDATION',
rule_name=rule_name)
iterator += 1
if selected_count > 0:
self.quality.generate_log_button()
if self.qgis_utils.error_group_exists():
group = self.qgis_utils.get_error_layers_group()
# # Check if group layer is empty
if group.findLayers():
self.qgis_utils.set_error_group_visibility(True)
else:
self.qgis_utils.remove_error_group_requested.emit()
def rejected(self):
pass
def select_all(self):
self.trw_quality_rules.selectAll()
def clear_selection(self):
self.trw_quality_rules.clearSelection()
def show_help(self):
self.qgis_utils.show_help("quality_rules")
class Symbology:
ERROR_LAYER = 'error_layer'
def __init__(self):
self.translatable_config_strings = TranslatableConfigStrings()
def get_default_style_group(self, names):
return {
names.OP_BOUNDARY_T: {
QgsWkbTypes.LineGeometry: 'style_boundary'
},
names.OP_BOUNDARY_POINT_T: {
QgsWkbTypes.PointGeometry: 'style_boundary_point'
},
names.OP_SURVEY_POINT_T: {
QgsWkbTypes.PointGeometry: 'style_survey_point'
},
names.OP_CONTROL_POINT_T: {
QgsWkbTypes.PointGeometry: 'style_control_point'
},
names.OP_PLOT_T: {
QgsWkbTypes.PointGeometry: 'style_plot_point',
QgsWkbTypes.PolygonGeometry: 'style_plot_polygon'
},
names.OP_BUILDING_T: {
QgsWkbTypes.PointGeometry: 'style_building_point',
QgsWkbTypes.PolygonGeometry: 'style_building'
},
names.OP_BUILDING_UNIT_T: {
QgsWkbTypes.PointGeometry: 'style_building_unit_point',
QgsWkbTypes.PolygonGeometry: 'style_building_unit_25'
},
names.OP_RIGHT_OF_WAY_T: {
QgsWkbTypes.PointGeometry: 'style_right_of_way_point',
QgsWkbTypes.PolygonGeometry: 'style_right_of_way'
},
self.ERROR_LAYER: {
QgsWkbTypes.PointGeometry: 'style_point_error',
QgsWkbTypes.LineGeometry: 'style_line_error',
QgsWkbTypes.PolygonGeometry: 'style_polygon_error'
}
}
def get_supplies_style_group(self, names):
return {
names.GC_PLOT_T: {
QgsWkbTypes.PolygonGeometry: 'style_supplies_plot_polygon'
}
}
def get_custom_error_layers(self):
translated_strings = self.translatable_config_strings.get_translatable_config_strings()
return {
translated_strings[CHECK_BOUNDARIES_COVERED_BY_PLOTS]: {
'es': 'style_boundary_should_be_covered_by_plot_es',
'en': 'style_boundary_should_be_covered_by_plot_en'
},
translated_strings[CHECK_PLOTS_COVERED_BY_BOUNDARIES]: {
'es': 'style_plot_should_be_covered_by_boundary_es',
'en': 'style_plot_should_be_covered_by_boundary_en'
},
translated_strings[CHECK_BOUNDARY_POINTS_COVERED_BY_BOUNDARY_NODES]: {
'es': 'style_boundary_points_should_be_covered_by_boundary_nodes_es',
'en': 'style_boundary_points_should_be_covered_by_boundary_nodes_en'
},
translated_strings[CHECK_BOUNDARY_NODES_COVERED_BY_BOUNDARY_POINTS]: {
'es': 'style_boundary_nodes_should_be_covered_by_boundary_points_es',
'en': 'style_boundary_nodes_should_be_covered_by_boundary_points_en'
}
}
def get_error_layer_name(self):
return self.ERROR_LAYER
def error_group_exists(self):
root = QgsProject.instance().layerTreeRoot()
translated_strings = TranslatableConfigStrings.get_translatable_config_strings(
)
return root.findGroup(
translated_strings[ERROR_LAYER_GROUP]) is not None
