HYTOS

# coding: utf-8

"""This is HMB dialog module"""

import os

import sys

sys.path.insert(0, os.path.join(os.path.dirname(os.path.realpath(__file__)), 'Commands'))

import FenceCommand

from PyQt5.QtCore import *

from PyQt5.QtGui import *

from PyQt5.QtWidgets import *

import openpyxl

from openpyxl.styles import *

from AppDocData import AppDocData, Config

sys.path.insert(0, os.path.join(os.path.dirname(os.path.realpath(__file__)), 'Shapes'))

class QHMBDialog(QDialog):

    def __init__(self, parent):

        from HMB_UI import Ui_HMBDialog

        from TableWidgetEx import QTableWidgetEx

        from WaitingSpinnerWidget import QtWaitingSpinner

        QDialog.__init__(self, parent)

        try:

            self.ui = Ui_HMBDialog()

            self.ui.setupUi(self)

            self.waiting_spinner = QtWaitingSpinner(self)

            self.ui.horizontalLayoutSpinnerWaiting.addWidget(self.waiting_spinner)

            self.ui.buttonBox.button(QDialogButtonBox.Ok).setIcon(QIcon(':/newPrefix/OK.svg'))

            self.ui.buttonBox.button(QDialogButtonBox.Ok).setText(self.tr('Import'))

            self.ui.buttonBox.button(QDialogButtonBox.Close).setIcon(QIcon(':/newPrefix/Remove.svg'))

            self.fill_hmb_data(None)

            self.ui.tableViewHMB.setAlternatingRowColors(True)

            self.ui.toolButtonHMBFilePath.clicked.connect(self.on_open_hmb_file)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \

                      f"{sys.exc_info()[-1].tb_lineno}"

            App.mainWnd().addMessage.emit(MessageType.Error, message)

    def fill_hmb_data(self, file_path: str):

        """load hmb data and fill table view"""

        import uuid

        try:

            hmbs = AppDocData.get_hmb_data(file_path)

            if not hmbs:

                return

            model = QStandardItemModel()

            header = ['UID', 'StreamNumber']

            for hmb in hmbs:

                UID = hmb.uid

                STREAM_NO = hmb.stream_no

                items = [QStandardItem(UID), QStandardItem(STREAM_NO)]

                for data in sorted(hmb.data, key=lambda param: param.index):

                    if hmbs.index(hmb) == 0:

                        header.append(f"{data.name}\n({data.unit})" if data.unit else f"{data.name}")

                    items.append(QStandardItem(data.value))

                model.appendRow(items)

            model.setHorizontalHeaderLabels(header)

            self.ui.tableViewHMB.setModel(model)

            self.ui.tableViewHMB.resizeColumnsToContents()

            self.ui.tableViewHMB.setEditTriggers(QAbstractItemView.NoEditTriggers)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \

                      f"{sys.exc_info()[-1].tb_lineno}"

            App.mainWnd().addMessage.emit(MessageType.Error, message)

    class Worker(QThread):

        finished = pyqtSignal()

        def __init__(self, file_path: str):

            super().__init__()

            self._file_path = file_path

        def run(self):

            """execute thread"""

            import math

            import pandas as pd

            from HMBTable import HMBData, StreamData

            hmb_list = []

            sheets = pd.read_excel(self._file_path, sheet_name=None, header=None, convert_float=False)

            for name, df in sheets.items():

                rows, cols = df.shape[0], df.shape[1]

                for col in range(2, cols):

                    stream_no = df.iloc[0, col]

                    from_ = df.iloc[1, col]

                    to_ = df.iloc[2, col]

                    hmb = HMBData()

                    hmb.stream_no = stream_no

                    hmb.hfrom = from_

                    hmb.hto = to_

                    data = []

                    for row in range(3, rows):

                        value_ = df.iloc[row, 0]

                        name = value_ if value_ else ''

                        value_ = df.iloc[row, 1]

                        unit = value_ if value_ else ''

                        value_ = df.iloc[row, col]

                        value = value_ if (type(value_) is str) or (type(value_) is float and not math.isnan(value_)) \

                            else ''

                        data.append(StreamData(name, unit, value, row))

                    hmb.data = data

                    hmb_list.append(hmb)

                break

            app_doc_data = AppDocData.instance()

            app_doc_data.save_hmb_data(hmb_list)

            self.finished.emit()

    def on_open_hmb_file(self):

        """open hmb file"""

        from HMBTable import HMBData, StreamData

        options = QFileDialog.Options()

        options |= QFileDialog.DontUseNativeDialog

        file, _ = QFileDialog.getOpenFileName(self, self.tr('Import', "Select Excel File"),

                                               os.getcwd(), "excel files (*.xlsx)", options=options)

        if file:

            self.ui.lineEditHMBFilePath.setText(file)

    def accept(self):

        """no more used"""

        """accept dialog"""

        from HMBTable import HMBTable, HMBData

        from SymbolAttr import SymbolAttr

        def on_finished():

            self.fill_hmb_data(None)

            self.waiting_spinner.stop()

        try:

            file_path = self.ui.lineEditHMBFilePath.text()

            if file_path:

                self.worker = QHMBDialog.Worker(file_path)

                self.worker.finished.connect(on_finished)

                self.waiting_spinner.start()

                self.worker.start()

            else:

                QMessageBox.warning(self, self.tr('Warning'), self.tr('Please, select a HMB excel file'))

                """

                app_doc_data = AppDocData.instance()

                model = self.ui.tableViewHMB.model()

                app_doc_data.save_hmb_model(model)

                QDialog.accept(self)

                """

        except Exception as ex:

            message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \

                      f"{sys.exc_info()[-1].tb_lineno}"

            QMessageBox.warning(self, self.tr('Warning'), message)

    def reject(self):

        """reject dialog"""

        QDialog.reject(self)