mncheck/ui/dlg_main.py

"""
"""
from core import mncheck, checking
import importlib
import logging
from qgis.core import QgsProject  # @UnresolvedImport

from PyQt5 import QtWidgets
from PyQt5 import uic
from PyQt5.Qt import Qt
from PyQt5.QtGui import QIcon, QPixmap
from PyQt5.QtWidgets import QApplication, QTreeWidgetItem

from core.constants import MAIN, RSCDIR
from core.mncheck import QgsModel


logger = logging.getLogger("mncheck")

Ui_Main, _ = uic.loadUiType(MAIN / 'ui'/ 'dlg_main.ui')

# SCHEMAS = ["mn1_rec", "mn2_rec", "mn3_pro", "mn3_exe", "mn3_rec"]

class DlgMain(QtWidgets.QDialog):
    def __init__(self, iface, parent=None):
        super(DlgMain, self).__init__(parent)
        self.available_schemas = mncheck.list_schemas()        
        self.iface = iface
        self.schema_lib = None
        
        self.createWidgets()

    def createWidgets(self):
        """ set up the interface """
        self.ui = Ui_Main()
        self.ui.setupUi(self)
        
        self.ui.btn_run.setIcon(QIcon(RSCDIR / "play.png"))
        self.ui.btn_run.clicked.connect(self.run)
        
        self.ui.btn_help.setIcon(QIcon(RSCDIR / "question.png"))
        self.ui.btn_help.clicked.connect(self.show_help)
        
        self.ui.btn_settings.setIcon(QIcon(RSCDIR / "settings.png"))
        self.ui.btn_settings.clicked.connect(self.show_settings)

        for i, schema_name in enumerate(self.available_schemas):
            s = mncheck.get_schema(schema_name)
            try:
                self.ui.cbb_schemas.addItem(s.SCHEMA_NAME, i)
            except AttributeError:
                self.ui.cbb_schemas.addItem(schema_name, i)
            
        self.ui.cbb_schemas.currentIndexChanged.connect(self.update_layers_list)
        
        self.ui.tree_report.setColumnWidth(0, 35)
        self.ui.tree_report.itemClicked.connect(self.tree_item_clicked)
        
        self.update_layers_list()
    
    def current_schema(self):
        schema_name = self.available_schemas[int(self.ui.cbb_schemas.itemData(self.ui.cbb_schemas.currentIndex()))]
        logger.info("Selected schema: %s", schema_name)
    
        return mncheck.get_schema(schema_name)
    
    def update_layers_list(self):
        
        schema = self.current_schema()
        
        expected = [model.layername for model in schema.models]
        logger.info("Expected layers: %s", str(expected))

        found = [layer.name().lower() for layer in QgsProject.instance().mapLayers().values()]
        logger.info("Found layers: %s", str(found))

        self.ui.btn_run.setEnabled(True)

        self.ui.tree_report.clear()

        for layername in expected:
            
            item = QTreeWidgetItem()
            
            if layername.lower() in found:
                item.setIcon(0, QIcon(QPixmap(RSCDIR / "ok_16.png")))
                item.setText(1, layername)
            else:
                item.setIcon(0, QIcon(QPixmap(RSCDIR / "error_16.png")))
                item.setText(1, f"{layername}: La couche est introuvable")
                self.ui.btn_run.setEnabled(False)
                
            self.ui.tree_report.addTopLevelItem(item)


    def run(self):
        
        QApplication.setOverrideCursor(Qt.WaitCursor)
        self.ui.tree_report.clear()
        
        try:
            schema = self.current_schema()
            if not schema:
                logger.error("Aucun schéma sélectionné - Opération annulée")
                return
            
            checkers = mncheck.get_checkers(schema)
            if not checkers:
                logger.error("Aucun testeur trouvé dans le schéma")
                return
        
            for checker in checkers:
                logger.info(f"Execution du checker {checker.__name__}")
                self._run(checker)
        except:
            raise
        finally:
            QApplication.restoreOverrideCursor()
    
    def _run(self, checker):
        
        results = checker().run()
        
        for result in results:
            topitem = QTreeWidgetItem()
            
            if result.status == checking.SUCCESS:
                topitem.setIcon(0, QIcon(QPixmap(RSCDIR / "ok_16.png")))
                topitem.setText(1, f"{result.title}")
            elif result.status == checking.FAILURE:
                topitem.setIcon(0, QIcon(QPixmap(RSCDIR / "error_16.png")))
                topitem.setText(1, f"{result.title} ({len(result.errors)})")
            elif result.status == checking.ERROR:
                topitem.setIcon(0, QIcon(QPixmap(RSCDIR / "warning_16.png")))
                topitem.setText(1, f"{result.title} [Erreur inconnue]")
            else:
                topitem.setText(1, f"{result.title} [Résultat manquant]")
            
            self.ui.tree_report.addTopLevelItem(topitem)
            
            for err in result.errors:
                erritem = QTreeWidgetItem()
                
                msg = err.message
                data = None
                
                if "exc_info" in err.info:
                    data = err.info["exc_info"]
                    logger.debug("%s", err.message, err.info["exc_info"])
                    
                elif "model" in err.info:
                    data = err.info["model"]
                    msg = f"{data.layername} - {msg}"
                    
                elif "item" in err.info:
                    data = err.info["item"]
                    msg = f"{data} - {msg}"
                
                erritem.setText(1, msg)
                erritem.setData(1, Qt.UserRole, data)
                
                topitem.addChild(erritem)
        
    def tree_item_clicked(self, item, _):
        
        data = item.data(1, Qt.UserRole)
        
        if not data:
            return
        
        logger.debug("error clicked (data: %s)", data)
        
        if hasattr(data, "_feature"):
            self.zoom_to_feature(data.layer, data._feature)
            
        elif hasattr(data, "layer"):
            self.select_layer(data.layer)
            
        else:
            logger.error(f"Data unknown: {data}")
        
    def select_layer(self, layer):
        self.iface.setActiveLayer(layer)
        
    def zoom_to_feature(self, layer, feature):
        self.iface.setActiveLayer(layer)
        self.iface.mapCanvas().zoomToFeatureExtent(feature.geometry().boundingBox())
        layer.select(feature.id())
        
    def show_help(self):
        pass
    
    def show_settings(self):
        pass