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


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:
                treeitem = QTreeWidgetItem()
                
                treeitem.setText(1, err.message)
                if "exc_info" in err.info:
                    logger.debug("* %s\n%s", err.message, err.info["exc_info"])
                    treeitem.setData(1, Qt.UserRole, err.info["exc_info"])
                    
                topitem.addChild(treeitem)
        
        
        
    def tree_item_clicked(self, item, col):
        
        data = item.data(1, Qt.UserRole)
        
        
    def show_help(self):
        pass
    
    def show_settings(self):
        pass