mncheck/schemas/mn1_rec.py

'''

    Schéma de validation des données MN1

@author: olivier.massot, 2018
'''

import logging
from qgis.core import QgsProject, QgsGeometry, QgsWkbTypes

from core.cerberus_ import is_float, is_multi_int, is_int, \
    is_modern_french_date, CerberusValidator, CerberusErrorHandler, \
    _translate_messages
from core.checker import BaseChecker
from core.validation_errors import UniqueError, RelationError, \
    DuplicatedGeom, MissingItem, DimensionError, TechnicalValidationError
from core.validator import QgsModel, BaseValidator


logger = logging.getLogger("mncheck")


SCHEMA_NAME = "Schéma MN v1 REC"

XMIN, XMAX, YMIN, YMAX = 1341999, 1429750, 8147750, 8294000
CRS = 'EPSG:3949' # Coordinate Reference System

TOLERANCE = 1

class Artere(QgsModel):
    layername = "artere_geo"
    geom_type = QgsModel.GEOM_LINE
    crs = CRS
    bounding_box = (XMIN,YMIN,XMAX,YMAX)
    schema = {'AR_ID_INSE': {'type': 'string', 'empty': False, 'regex': r'50\d{3}'}, 
              'AR_LONG': {'empty': False, 'validator': is_float},
              'AR_ETAT': {'type': 'string', 'empty': False, 'allowed': ['0', '1', '2', '3', '4']}, 
              'AR_OCCP': {'type': 'string', 'empty': False, 'allowed': ['0', '1.1', '1.2', '2', '3', '4']}, 
              'AR_NOEUD_A': {'type': 'string', 'empty': False, 'maxlength': 20}, 
              'AR_NOEUD_B': {'type': 'string', 'empty': False, 'maxlength': 20}, 
              'AR_NB_FOUR': {'empty': False, 'validator': is_multi_int}, 
              'AR_FOU_DIS': {'empty': False, 'validator': is_int}, 
              'AR_TYPE_FO': {'type': 'string', 'multiallowed': ['PVC', 'PEHD', 'SOUS-TUBAGE PEHD', 'SOUS-TUBAGE  SOUPLE', 'FACADE', 'AERIEN', 'ENCORBELLEMENT', 'AUTRE']}, 
              'AR_DIAM_FO': {'type': 'string', 'multiallowed': ['10', '14', '18', '25', '28', '32', '40', '45', '60', '80', '150', 'NUL']}, 
              'AR_PRO_FOU': {'type': 'string', 'multiallowed': ['MANCHE NUMERIQUE', 'COLLECTIVITE', 'ORANGE', 'PRIVE', 'ERDF', 'AUTRE (à préciser)']}, 
              'AR_PRO_CAB': {'type': 'string', 'empty': False, 'allowed': ['MANCHE NUMERIQUE']}, 
              'AR_GEST_FO': {'type': 'string', 'multiallowed': ['MANCHE NUMERIQUE', 'MANCHE TELECOM', 'COLLECTIVITE', 'ORANGE', 'MANCHE FIBRE', 'PRIVE', 'ERDF', 'AUTRE (à préciser)', 'NUL']}, 
              'AR_UTIL_FO': {'type': 'string', 'multiallowed': ['MANCHE NUMERIQUE', 'MANCHE TELECOM', 'COLLECTIVITE', 'ORANGE', 'MANCHE FIBRE', 'PRIVE', 'AUTRE (à préciser)', 'NUL']}, 
              'AR_DATE_IN': {'empty': False, 'validator': is_modern_french_date}, 
              'AR_DATE_RE': {'empty': False, 'validator': is_modern_french_date}, 
              'AR_REF_PLA': {'type': 'string', 'maxlength': 100}, 
              'AR_SRC_GEO': {'type': 'string', 'maxlength': 50}, 
              'AR_QLT_GEO': {'type': 'string', 'empty': False, 'allowed': ['A', 'B', 'C']}, 
              'AR_PRO_MD': {'type': 'string', 'empty': False, 'default': 'MANCHE NUMERIQUE', 'allowed': ['MANCHE NUMERIQUE']}, 
              'AR_COMMENT': {'type': 'string', 'maxlength': 300, 'empty': True}, 
              'AR_STATUT': {'type': 'string', 'empty': False, 'allowed': ['APS', 'APD', 'EXE', 'REC']}}

    def __repr__(self):
        return "Artere {}-{}".format(self.AR_NOEUD_A, self.AR_NOEUD_B)

class Cable(QgsModel):
    layername = "cable_geo"
    geom_type = QgsModel.GEOM_LINE
    crs = CRS
    bounding_box = (XMIN,YMIN,XMAX,YMAX)
    schema = {'CA_NUMERO': {'type': 'string', 'maxlength': 17}, 
              'CA_TYPE': {'type': 'string', 'maxlength': 10, 'empty': False, 'allowed': ['AERIEN', 'IMMEUBLE', 'FACADE', 'MIXTE', 'SOUTERRAIN']}, 
              'CA_ETAT': {'type': 'string', 'maxlength': 1, 'empty': False, 'allowed': ['0', '1', '2', '3', '4']}, 
              'CA_LONG': {'validator': is_float}, 
              'CA_EQ_A': {'type': 'string', 'maxlength': 18}, 
              'CA_EQ_B': {'type': 'string', 'maxlength': 18}, 
              'CA_DIAMETR': {'empty': False, 'validator': is_float}, 
              'CA_COULEUR': {'type': 'string', 'maxlength': 20, 'empty': False, 'allowed': ['NOIR', 'BLEU', 'BLANC']}, 
              'CA_TECHNOL': {'type': 'string', 'maxlength': 17, 'empty': False, 'allowed': ['G657A2_M6', 'G657A2_M12']}, 
              'CA_NB_FO': {'validator': is_int}, 
              'CA_NB_FO_U': {'empty': False, 'validator': is_int}, 
              'CA_NB_FO_D': {'empty': False, 'validator': is_int}, 
              'CA_PRO': {'type': 'string', 'maxlength': 20, 'empty': False, 'allowed': ['MANCHE NUMERIQUE']}, 
              'CA_GEST': {'type': 'string', 'maxlength': 20, 'empty': False, 'allowed': ['MANCHE FIBRE']}, 
              'CA_DATE_IN': {'empty': False, 'validator': is_modern_french_date}, 
              'CA_COMMENT': {'type': 'string', 'maxlength': 300, 'empty': True}, 
              'CA_STATUT': {'type': 'string', 'maxlength': 14, 'empty': False, 'allowed': ['APS', 'APD', 'EXE', 'REC']}}

    def __repr__(self):
        return "Cable {}-{}".format(self.CA_EQ_A, self.CA_EQ_B)
    
class Equipement(QgsModel):
    layername = "equipement_passif"
    geom_type = QgsModel.GEOM_POINT
    crs = CRS
    bounding_box = (XMIN,YMIN,XMAX,YMAX)
    schema = {'EQ_NOM': {'type': 'string', 'maxlength': 10, 'contains_any_of': ['PBO', 'BPE', 'BAI']}, 
              'EQ_NOM_NOE': {'type': 'string', 'maxlength': 30}, 
              'EQ_ETAT': {'type': 'string', 'maxlength': 1, 'empty': False, 'allowed': ['0', '1', '2', '3', '4']}, 
              'EQ_OCCP': {'type': 'string', 'maxlength': 3, 'empty': False, 'allowed': ['0', '1.1', '1.2', '2', '3', '4']}, 
              'EQ_TYPE': {'type': 'string', 'empty': False, 'allowed': ['PBO', 'PBOE', 'BPE', 'BAI']}, 
              'EQ_TYPE_LQ': {'type': 'string', 'maxlength': 6, 'empty': False, 'allowed': ['PBO', 'BPE JB', 'BPE JD', 'BAIDC', 'BAIOP']}, 
              'EQ_TYPE_PH': {'type': 'string', 'maxlength': 24, 'empty': False, 'allowed': ['PBO 6', 'PBO 12', 'BPE 12EP', 'BPE 24EP', 'BPE 48EP', 'BPE 72EP', 'BPE 96EP', 'BPE 144EP', 'BPE 288EP', 'BPE 576EP', 'BPE 720EP', 'BAI']}, 
              'EQ_PRO': {'type': 'string', 'maxlength': 20, 'empty': False, 'allowed': ['MANCHE NUMERIQUE', 'COLLECTIVITE', 'ORANGE', 'PRIVE', 'AUTRE (à préciser)', 'NUL']}, 
              'EQ_GEST': {'type': 'string', 'maxlength': 20, 'empty': False, 'allowed': ['MANCHE NUMERIQUE', 'MANCHE TELECOM', 'COLLECTIVITE', 'ORANGE', 'MANCHE FIBRE', 'PRIVE', 'AUTRE (à préciser)', 'NUL']}, 
              'EQ_HAUT': {'empty': False, 'validator': is_float}, 
              'EQ_DATE_IN': {'empty': False, 'validator': is_modern_french_date}, 
              'EQ_COMMENT': {'type': 'string', 'maxlength': 300, 'empty': True}, 
              'EQ_STATUT': {'type': 'string', 'maxlength': 14, 'empty': False, 'allowed': ['APS', 'APD', 'EXE', 'REC']}}
        
    def __repr__(self):
        return "Equipement {}".format(self.EQ_NOM)

class Noeud(QgsModel):
    layername = "noeud_geo"
    geom_type = QgsModel.GEOM_POINT
    crs = CRS
    bounding_box = (XMIN,YMIN,XMAX,YMAX)
    schema = {'NO_NOM': {'type': 'string', 'maxlength': 30}, 
              'NO_ID_INSE': {'type': 'string', 'empty': False, 'regex': r'50\d{3}'}, 
              'NO_VOIE': {'type': 'string', 'maxlength': 100}, 
              'NO_ETAT': {'type': 'string', 'maxlength': 1, 'empty': False, 'allowed': ['0', '1', '2', '3', '4']}, 
              'NO_OCCP': {'type': 'string', 'maxlength': 3, 'empty': False, 'allowed': ['0', '1.1', '1.2', '2', '3', '4']}, 
              'NO_TYPE': {'type': 'string', 'maxlength': 3, 'empty': False, 'allowed': ['CHA', 'POT', 'LTE', 'SEM', 'FAC', 'OUV', 'IMM']}, 
              'NO_TYPE_LQ': {'type': 'string', 'maxlength': 10, 'empty': False, 'allowed': ['CHTIR', 'CHRACC', 'POT', 'NRO', 'PM', 'MIMO', 'FAC', 'OUV', 'IMM']}, 
              'NO_TYPE_PH': {'type': 'string', 'maxlength': 20, 'empty': False, 'allowed': ['CHAMBRE', 'POTEAU', 'ARMOIRE', 'SHELTER', 'BATIMENT', 'SITE MIMO', 'FACADE', 'OUVRAGE', 'IMMEUBLE']}, 
              'NO_CODE_PH': {'type': 'string', 'maxlength': 20}, 
              'NO_TECH_PS': {'type': 'string', 'maxlength': 20, 'multiallowed': ['COAX', 'CUT', 'ECL', 'ELEC', 'VP', 'OPT', 'NC']}, 
              'NO_AMO': {'type': 'string', 'maxlength': 20}, 
              'NO_PLINOX': {'required':False, 'type': 'string', 'maxlength': 3, 'allowed': ['OUI', 'NON']}, 
              'NO_X': {'empty': False, 'validator': is_float}, 
              'NO_Y': {'empty': False, 'validator': is_float}, 
              'NO_PRO': {'type': 'string', 'maxlength': 20, 'empty': False, 'allowed': ['MANCHE NUMERIQUE', 'COLLECTIVITE', 'ORANGE', 'ERDF', 'PRIVE', 'ENEDIS', 'AUTRE (à préciser)', 'NUL']}, 
              'NO_GEST': {'type': 'string', 'maxlength': 20, 'empty': False, 'allowed': ['MANCHE NUMERIQUE', 'MANCHE TELECOM', 'COLLECTIVITE', 'ORANGE', 'ERDF', 'ENEDIS', 'MANCHE FIBRE', 'PRIVE', 'AUTRE (à préciser)', 'NUL']}, 
              'NO_HAUT': {'empty': False, 'validator': is_float}, 
              'NO_DATE_IN': {'empty': False, 'validator': is_modern_french_date}, 
              'NO_REF_PLA': {'type': 'string', 'maxlength': 100}, 
              'NO_SRC_GEO': {'type': 'string', 'maxlength': 50}, 
              'NO_QLT_GEO': {'type': 'string', 'maxlength': 1, 'empty': False, 'allowed': ['A', 'B', 'C']}, 
              'NO_PRO_MD': {'type': 'string', 'maxlength': 20, 'empty': False, 'allowed': ['MANCHE NUMERIQUE']}, 
              'NO_COMMENT': {'type': 'string', 'maxlength': 300, 'empty': True}, 
              'NO_STATUT': {'type': 'string', 'maxlength': 14, 'empty': False, 'allowed': ['APS', 'APD', 'EXE', 'REC']}}

    def __repr__(self):
        return "Noeud {}".format(self.NO_NOM)
    
class Tranchee(QgsModel):
    layername = "tranchee_geo"
    geom_type = QgsModel.GEOM_LINE
    crs = CRS
    bounding_box = (XMIN,YMIN,XMAX,YMAX)
    schema = {'TR_ID_INSE': {'type': 'string', 'empty': False, 'regex': r'50\d{3}'}, 
              'TR_VOIE': {'type': 'string', 'maxlength': 200}, 
              'TR_TYP_IMP': {'type': 'string', 'empty': False, 'allowed': ['ACCOTEMENT STABILISE', 'ACCOTEMENT NON STABILISE', 'CHAUSSEE LOURDE', 'CHAUSSEE LEGERE', 'FOSSE', 'TROTTOIR', 'ESPACE VERT', 'ENCORBELLEMENT']}, 
              'TR_MOD_POS': {'type': 'string', 'empty': False, 'allowed': ['TRADITIONNEL', 'MICRO TRANCHEE', 'FONCAGE 60', 'FONCAGE 90', 'FONCAGE 120', 'TRANCHEUSE', 'FORAGE URBAIN', 'FORAGE RURAL', 'ENCORBELLEMENT']}, 
              'TR_LONG': {'empty': False, 'validator': is_float}, 
              'TR_LARG': {'empty': False, 'validator': is_float}, 
              'TR_REVET': {'empty':True, 'type': 'string', 'allowed': ['SABLE', 'BICOUCHE', 'ENROBE', 'BETON', 'PAVE', 'TERRAIN NATUREL']}, 
              'TR_CHARGE': {'empty': False, 'validator': is_float}, 
              'TR_GRILLAG': {'empty':True, 'validator': is_float}, 
              'TR_REMBLAI': {'type': 'string'}, 
              'TR_PLYNOX': {'type': 'string', 'empty': False, 'allowed': ['OUI', 'NON']}, 
              'TR_PRO_VOI': {'type': 'string', 'empty': False, 'allowed': ['COMMUNE', 'COMMUNAUTE DE COMMUNES', 'DEPARTEMENT', 'ETAT', 'PRIVE']}, 
              'TR_GEST_VO': {'type': 'string', 'empty': False, 'allowed': ['COMMUNE', 'COMMUNAUTE DE COMMUNES', 'DEPARTEMENT', 'ETAT', 'PRIVE']}, 
              'TR_SCHEMA': {'maxlength': 100, 'type': 'string'}, 
              'TR_DATE_IN': {'empty': False, 'validator': is_modern_french_date}, 
              'TR_SRC_GEO': {'type': 'string', 'maxlength': 50}, 
              'TR_QLT_GEO': {'type': 'string', 'empty': False, 'allowed': ['A', 'B', 'C']}, 
              'TR_PRO_MD': {'type': 'string', 'maxlength': 20}, 
              'TR_COMMENT': {'type': 'string', 'maxlength': 300, 'empty': True}, 
              'TR_STATUT': {'type': 'string', 'empty': False, 'allowed': ['APS', 'APD', 'EXE', 'REC']}}

    def __repr__(self):
        return "Tranchee {}".format(self.TR_VOIE)
    
class Zapbo(QgsModel):
    layername = "zapbo_geo"
    geom_type = QgsModel.GEOM_POLYGON
    crs = CRS
    bounding_box = (XMIN,YMIN,XMAX,YMAX)
    schema = {'ID_ZAPBO': {'type': 'string', 'maxlength': 30, 'contains_any_of': ['PBO', 'BPE']}, 
              'COMMENTAIR': {'type': 'string', 'maxlength': 254, 'empty': True}, 
              'STATUT': {'type': 'string', 'empty': False, 'allowed': ['APS', 'APD', 'EXE', 'REC']}}
    
    def __repr__(self):
        return "Zapbo {}".format(self.ID_ZAPBO)
    

models = [Artere, Cable, Equipement, Noeud, Tranchee, Zapbo]
    
####### Validateur

class Mn1Checker(BaseChecker):
    
    def __init__(self):
        super().__init__()
    
    def test_load_layers(self):
        """ Chargement des données """
        
        for model in models:
            layername = model.layername
            
            layer = next((l for l in QgsProject.instance().mapLayers().values() if l.name().lower() == layername.lower()))
            if not layer:
                self.log_error("Couche manquante", layername=layername, critical=True)
                continue
            
            model.layer = layer
            
        self.arteres = list(Artere.layer.getFeatures())
        self.cables = list(Cable.layer.getFeatures())
#         self.equipements = list(Equipement.layer.getFeatures())
#         self.noeuds = list(Noeud.layer.getFeatures())
        self.tranchees = list(Tranchee.layer.getFeatures())
#         self.zapbos = list(Zapbo.layer.getFeatures())
        
        self.dataset = {Artere: self.arteres,
                        Cable: self.cables,
                        Equipement: self.equipements,
                        Noeud: self.noeuds,
                        Tranchee: self.tranchees,
                        Zapbo: self.zapbos}
    
    def test_scr(self):
        """ Contrôle des projections """
        for model in models:
            if model.layer.crs().authid() != model.crs:
                self.log_error(f"Mauvaise projection (attendu: {model.crs})", layername=model.layername)

    def _validate_structure(self, model, features):
        v = CerberusValidator(model.schema, purge_unknown=True, error_handler=CerberusErrorHandler, require_all=True)
        for feature in features:
            attributes = dict(zip([f.name() for f in feature.fields()], feature.attributes()))
            v.validate(attributes)
            
            for field, verrors in v.errors.items():
                for err in verrors:
                    self.log_error(_translate_messages(err), layername=model.layername, field=field)

    def test_structure_arteres(self):
        """ Structure des données: Artères """
        self._validate_structure(Artere, self.arteres)

    def test_structure_cables(self):
        """ Structure des données: Cables """
        self._validate_structure(Cable, self.cables)

    def test_structure_equipements(self):
        """ Structure des données: Equipements """
        self._validate_structure(Equipement, self.equipements)
        
    def test_structure_noeuds(self):
        """ Structure des données: Noeuds """
        self._validate_structure(Noeud, self.noeuds)

    def test_structure_tranchees(self):
        """ Structure des données: Tranchées """
        self._validate_structure(Tranchee, self.tranchees)

    def test_structure_zapbos(self):
        """ Structure des données: Zapbos """
        self._validate_structure(Zapbo, self.zapbos)

    def test_geometry_validity(self):
        """ Contrôle de la validité des géométries """
        for model in models:
            for f in self.dataset[model]:
                if not f.geometry().isGeosValid():
                    self.log_error("La géométrie de l'objet est invalide", layername=model.layername, field="geom")

    def test_geometry_type(self):
        for model in models:
            for f in self.dataset[model]:
                if QgsWkbTypes.singleType(f.geometry().wkbType()) != model.geom_type:
                    self.log_error("Type de géométrie invalide (attendu: {})".format(QgsModel.GEOM_NAMES[model.geom_type]), layername=model.layername, field="geom")

    def test_bounding_box(self):
                
        for model in models:
            xmin, ymin, xmax, ymax = model.bounding_box
            
            for f in self.dataset[model]:
                
                bb = f.geometry().boundingBox()
                x1, y1, x2, y2 = (bb.xMinimum(), bb.yMinimum(), bb.xMaximum(), bb.yMaximum())
                
                if any(x < xmin or x > xmax for x in (x1, x2)) or \
                   any(y < ymin or y > ymax for y in (y1, y2)):
                    self.log_error("Hors de l'emprise autorisée", layername=model.layername, field="geom")


    def test_duplicates(self):
        """ Recherche de doublons """        
        
        # TODO: séparer le chargement des données et le contrôle des doublons
        
        self.noeuds = {}
        for noeud in self.dataset[Noeud]:
            if not noeud.NO_NOM in self.noeuds:
                self.noeuds[noeud.NO_NOM] = noeud
            else:
                self.log_error("Doublons dans le champs: {}".format(noeud), layername=Noeud.layername, field="NO_NOM")
        
        self.equipements = {}
        for equipement in self.dataset[Equipement]:
            if not equipement.EQ_NOM in self.equipements:
                self.equipements[equipement.EQ_NOM] = equipement
            else:
                self.log_error("Doublons dans le champs: {}".format(equipement), layername=Equipement.layername, field="EQ_NOM")
                
        self.zapbos = {}
        for zapbo in self.dataset[Zapbo]:
            if not zapbo.ID_ZAPBO in self.zapbos:
                self.zapbos[zapbo.ID_ZAPBO] = zapbo
            else:
                self.log_error("Doublons dans le champs: {}".format(zapbo), layername=Zapbo.layername, field="ID_ZAPBO")
        
        
    def test_constraints(self):
        """ Contrôle des contraintes relationnelles """
        
        # rattachement les noeuds aux artères     
        for artere in self.arteres:
            try:
                artere.noeud_a = self.noeuds[artere.AR_NOEUD_A]
            except KeyError:
                artere.noeud_a = None
                self.log_error(RelationError("Le noeud '{}' n'existe pas".format(artere.AR_NOEUD_A), layername=Artere.layername, field="AR_NOEUD_A"))
                
            try:
                artere.noeud_b = self.noeuds[artere.AR_NOEUD_B]
            except KeyError:
                artere.noeud_b = None
                self.log_error(RelationError("Le noeud '{}' n'existe pas".format(artere.AR_NOEUD_B), layername=Artere.layername, field="AR_NOEUD_A"))
        
        # rattachement des equipements aux cables
        for cable in self.cables:
            try:
                cable.equipement_a = self.equipements[cable.CA_EQ_A]
            except KeyError:
                cable.equipement_a = None
                self.log_error(RelationError("L'équipement '{}' n'existe pas".format(cable.CA_EQ_A), layername=Cable.layername, field="CA_EQ_A"))
                
            try:
                cable.equipement_b = self.equipements[cable.CA_EQ_B]
            except KeyError:
                cable.equipement_b = None
                self.log_error(RelationError("L'équipement '{}' n'existe pas".format(cable.CA_EQ_B), layername=Cable.layername, field="CA_EQ_B"))

        # rattachement des equipements aux noeuds
        for equipement in self.equipements.values():
            try:
                equipement.noeud = self.noeuds[equipement.EQ_NOM_NOE]
            except KeyError:
                equipement.noeud = None
                self.log_error(RelationError("Le noeud '{}' n'existe pas".format(equipement.EQ_NOM_NOE, equipement.EQ_NOM), layername=Equipement.layername, field="EQ_NOM_NOE"))

        # verifie que tous les equipements sont l'equipement B d'au moins un cable
        equipements_b = [cable.CA_EQ_B for cable in self.cables]
        for eq_id in self.equipements:
            if self.equipements[eq_id].EQ_TYPE == "BAI":
                continue
            if not eq_id in equipements_b:
                self.log_error(RelationError("L'equipement '{}' n'est l'équipement B d'aucun cable".format(eq_id), layername=Equipement.layername, field="EQ_NOM"))


    def test_graphic_duplicates(self):
        """ Recherche de doublons graphiques """
            
        # controle des doublons graphiques
        for i, tranchee in enumerate(self.tranchees):
            for other in self.tranchees[i+1:]:
                if tranchee.geom == other.geom:
                    self.log_error(DuplicatedGeom("Une entité graphique est dupliquée".format(tranchee), layername=Tranchee.layername, field="geom"))
                    
        for i, artere in enumerate(self.arteres):
            for other in self.arteres[i+1:]:
                if artere.geom == other.geom:
                    self.log_error(DuplicatedGeom("Une entité graphique est dupliquée ('{}')".format(artere), layername=Artere.layername, field="geom"))

        for i, cable in enumerate(self.cables):
            for other in self.cables[i+1:]:
                if cable.geom == other.geom and cable.CA_EQ_A == other.CA_EQ_A and cable.CA_EQ_B == other.CA_EQ_B:
                    self.log_error(DuplicatedGeom("Une entité graphique est dupliquée ('{}')".format(cable), layername=Cable.layername, field="geom"))
        
        ls_noeuds = list(self.noeuds.values())
        for i, noeud in enumerate(ls_noeuds):
            for other in ls_noeuds[i+1:]:
                if noeud.geom == other.geom:
                    self.log_error(DuplicatedGeom("Une entité graphique est dupliquée ('{}')".format(noeud), layername=Noeud.layername, field="geom"))
        del ls_noeuds
        
        ls_zapbos = list(self.zapbos.values())
        for i, zapbo in enumerate(ls_zapbos):
            for other in ls_zapbos[i+1:]:
                if zapbo.geom == other.geom:
                    self.log_error(DuplicatedGeom("Une entité graphique est dupliquée ('{}')".format(zapbo), layername=Zapbo.layername, field="geom"))
        del ls_zapbos
        
    def test_positions_noeuds(self):
        """ Contrôle de la position des noeuds """
        
        # Arteres: comparer la géométrie à celle des noeuds
        for artere in self.arteres:
            if not artere.noeud_a or not artere.noeud_b:
                continue
            
            if not any(((artere.points[0].distanceSquared(artere.noeud_a.points[0]) <= TOLERANCE and \
                         artere.points[-1].distanceSquared(artere.noeud_b.points[0]) <= TOLERANCE), 
                        (artere.points[0].distanceSquared(artere.noeud_b.points[0]) <= TOLERANCE and \
                         artere.points[-1].distanceSquared(artere.noeud_a.points[0]) <= TOLERANCE))):
                self.log_error(MissingItem("Pas de noeud aux coordonnées attendues ('{}')".format(artere), layername=Artere.layername, field="geom"))
        
    def test_positions_equipements(self):
        """ Contrôle de la position des équipements """
        
        # Cables: comparer la géométrie à celle des equipements (on utilise en fait la geom du noeud correspondant à l'équipement)
        for cable in self.cables:
            if not cable.equipement_a or not cable.equipement_b or not cable.is_geometry_valid() or not cable.equipement_a.noeud or not cable.equipement_b.noeud:
                continue
            
            if not any(((cable.points[0].distanceSquared(cable.equipement_a.noeud.points[0]) <= TOLERANCE and \
                         cable.points[-1].distanceSquared(cable.equipement_b.noeud.points[0]) <= TOLERANCE), 
                        (cable.points[0].distanceSquared(cable.equipement_b.noeud.points[0]) <= TOLERANCE and \
                         cable.points[-1].distanceSquared(cable.equipement_a.noeud.points[0]) <= TOLERANCE))):
            
                self.log_error(MissingItem("Pas d'equipement aux coordonnées attendues ('{}')".format(cable), layername=Cable.layername, field="geom"))
            
    def test_tranchee_artere(self):
        """ Chaque tranchée a au moins une artère """

        arteres_full_buffer = QgsGeometry().unaryUnion([a.geom for a in self.arteres]).buffer(TOLERANCE, 100)
        
        for tranchee in self.tranchees:
            if not arteres_full_buffer.contains(tranchee.geom):
                self.log_error(MissingItem("Tranchée ou portion de tranchée sans artère ('{}')".format(tranchee), layername=Tranchee.layername, field="*"))
        
    def test_cable_artere(self):
        """ Chaque cable a au moins une artère (sauf baguettes) """
        arteres_full_buffer = QgsGeometry().unaryUnion([a.geom for a in self.arteres]).buffer(TOLERANCE, 100)
        
        # Verifie que chaque cable a au moins une artère (sauf si commentaire contient 'baguette')
        for cable in self.cables:
            if "baguette" in cable.CA_COMMENT.lower() or not cable.is_geometry_valid():
                continue
            if not arteres_full_buffer.contains(cable.geom):
                self.log_error(MissingItem("Cable ou portion de cable sans artère ('{}')".format(cable), layername=Cable.layername, field="*"))
        
    def test_artere_cable(self):
        """ Chaque artère a au moins une cable (sauf cas spécifiques) """
        
        # Verifie que chaque artère a au moins un cable (sauf si commentaire contient un de ces mots 'racco client adductio attente bus 'sans cable'')
        
        cables_full_buffer = QgsGeometry().unaryUnion([c.geom for c in self.cables]).buffer(TOLERANCE, 100)
        
        for artere in self.arteres:
            if any(x in artere.AR_COMMENT.lower() for x in ['racco','client','adductio','attente','bus','sans cable']):
                continue
            if not cables_full_buffer.contains(artere.geom):
                self.log_error(MissingItem("Artère sans cable ('{}')".format(artere), layername=Artere.layername, field="*"))
    
    
    def test_dimensions(self):
        """ Contrôle des dimensions logiques """
        
        for artere in self.arteres:
            try:
                if not int(artere.AR_FOU_DIS) <= int(artere.AR_NB_FOUR):
                    self.log_error(DimensionError("Le nombre de fourreaux disponibles doit être inférieur au nombre total ('{}')".format(artere), layername=Artere.layername, field="AR_FOU_DIS"))
            except (TypeError, ValueError):
                pass
         
        for cable in self.cables:
            try:
                if not int(cable.CA_NB_FO_U) <= int(cable.CA_NB_FO):
                    self.log_error(DimensionError("Le nombre de fourreaux utilisés doit être inférieur au nombre total ('{}')".format(cable), layername=Cable.layername, field="CA_NB_FO_U"))
                if not int(cable.CA_NB_FO_D) <= int(cable.CA_NB_FO):
                    self.log_error(DimensionError("Le nombre de fourreaux disponibles doit être inférieur au nombre total ('{}')".format(cable), layername=Cable.layername, field="CA_NB_FO_D"))
            except (TypeError, ValueError):
                pass
         
    def test_pbos(self):
        """ PBO / ZAPBO """
        
        # Verifier que chaque equipement de type PBO est contenu dans une zapbo, et que le nom de la zapbo contient le nom de l'equipement
        for equipement in self.equipements.values():
            if not equipement.EQ_TYPE == "PBO":
                continue
             
            #zapbos englobant l'equipement
            candidates = []
            for zapbo in self.zapbos.values():
                if zapbo.geom.contains(equipement.geom):
                    candidates.append(zapbo)
                     
            # le pbo doit être contenu dans une zapbo
            if not candidates:
                self.log_error(MissingItem("Le PBO n'est contenu dans aucune ZAPBO: {}".format(equipement), layername=Equipement.layername, field="geom"))
                continue
             
            # On se base sur le nom pour trouver la zapbo correspondante
            try:
                equipement.zapbo = next((z for z in candidates if equipement.EQ_NOM in z.ID_ZAPBO))
            except StopIteration:
                self.log_error(MissingItem("Le nom du PBO ne coincide avec le nom d'aucune des ZAPBO qui le contient: {}".format(equipement), layername=Equipement.layername, field="EQ_NOM"))
                break
            
            # TODO: revoir et déplacer le calcul du nombre de prises
            if not hasattr(equipement.zapbo, "nb_prises") or equipement.zapbo.nb_prises is None:
                equipement.zapbo.nb_prises = 0
             
    def test_pbo_dimension(self):
        """ Dimensionnement des PBO """
        for equipement in self.equipements.values():
            if not equipement.EQ_TYPE == "PBO":
                continue
             
            # Controle du dimensionnement des PBO
            if equipement.EQ_TYPE_PH == 'PBO 6' and not equipement.zapbo.nb_prises < 6:
                self.log_error(DimensionError("Le PBO 6 contient plus de 5 prises: {}".format(equipement), layername=Equipement.layername, field="*"))
         
            if equipement.EQ_TYPE_PH == 'PBO 12' and not equipement.zapbo.nb_prises >= 6 and equipement.zapbo.nb_prises <= 8:
                self.log_error(DimensionError("Le PBO 12 contient mois de 6 prises ou plus de 8 prises: {}".format(equipement), layername=Equipement.layername, field="*"))
         
            if equipement.zapbo.STATUT == "REC" and not equipement.EQ_STATUT == "REC":
                self.log_error(TechnicalValidationError("Le statut du PBO n'est pas cohérent avec le statut de sa ZAPBO: {}".format(equipement), layername=Equipement.layername, field="*"))
         
            if equipement.EQ_STATUT == "REC" and not equipement.zapbo.STATUT == "REC" and not equipement.zapbo.ID_ZAPBO[:4].lower() == "att_":
                self.log_error(TechnicalValidationError("Le statut du PBO n'est pas cohérent avec le statut de sa ZAPBO: {}".format(equipement), layername=Equipement.layername, field="*"))