HYTOS

# coding: utf-8

"""

    This is area configuration module

"""

import os

import sys

from PyQt5.QtCore import *

from PyQt5.QtGui import *

from PyQt5.QtWidgets import *

from AppDocData import AppDocData, MessageType

from App import App

from EngineeringAbstractItem import QEngineeringAbstractItem

from EngineeringLineItem import QEngineeringLineItem

from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

from SymbolSvgItem import SymbolSvgItem

from EngineeringEquipmentItem import QEngineeringEquipmentItem

from EngineeringInstrumentItem import QEngineeringInstrumentItem

from EngineeringVendorItem import QEngineeringVendorItem

from EngineeringSpecBreakItem import QEngineeringSpecBreakItem

from EngineeringErrorItem import QEngineeringErrorItem

from EngineeringEndBreakItem import QEngineeringEndBreakItem

from EngineeringUnknownItem import QEngineeringUnknownItem

from EngineeringRunItem import QEngineeringRunItem

from QEngineeringOPCItem import QEngineeringOPCItem

import LineNoList_UI

class LineListDialog(QDialog):

    def __init__(self, parent):

        QDialog.__init__(self, parent)

        self.ui = LineNoList_UI.Ui_LineListTable()

        self.ui.setupUi(self)

        self.ui.tableViewLineList.setSortingEnabled(True)

        self.isAccepted = False

        self.code_data = None

        # load drawing list

        # skip

        datas = self.make_line_list_data()

        self.fill_data(datas)

        #self.ui.buttonBox.accepted.connect(self.accept)

        self.ui.buttonBox.button(QDialogButtonBox.Close).clicked.connect(self.reject)

        #self.settingTable(Table_Name, attribute_uid=attribute_uid, tableDatas=tableDatas)

    def get_from_name(self, run, item):

        return item.name + '(' + str(item.uid) + ')' if issubclass(type(item), SymbolSvgItem) else 'Line' + '(' + str(item.uid) + ')'

    def get_to_name(self, run, item):

        return item.name + '(' + str(item.uid) + ')' if issubclass(type(item), SymbolSvgItem) else 'Line' + '(' + str(item.uid) + ')'

    def fill_data(self, datas):

        model = QStandardItemModel()

        header = ['Line No', 'From', 'To', 'Stream No']

        row_datas = []

        for data in datas:

            row_datas.extend(data)

        for row_data in row_datas:

            line_no = row_data[0].owner.text()

            from_ = self.get_from_name(row_data[0], row_data[1])

            to_ = self.get_to_name(row_data[0], row_data[2])

            stream_no = row_data[1].stream_no

            items = [QStandardItem(line_no), QStandardItem(from_), QStandardItem(to_), QStandardItem(stream_no)]

            model.appendRow(items)

        model.setHorizontalHeaderLabels(header)

        self.ui.tableViewLineList.setModel(model)

        self.ui.tableViewLineList.resizeColumnsToContents()

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

    def make_line_list_data(self):

        app_doc_data = AppDocData.instance()

        try:

            scene = self.get_scene()

            self._symbols = []

            self._lines = [item for item in scene.items() if type(item) is QEngineeringLineItem]

            lineNos = []

            start_line_runs = []

            spec_breaks = []

            break_items_pair = []

            end_breaks = []

            for end_break in [item for item in scene.items() if type(item) is QEngineeringEndBreakItem]:

                end_breaks.append(end_break)

            for item in scene.items():

                # for data binding

                if issubclass(type(item), QEngineeringAbstractItem):

                    item.getAttributes()

                if type(item) is QEngineeringSpecBreakItem:

                    spec_breaks.append(item)

                elif issubclass(type(item), SymbolSvgItem) and not (type(item) is QEngineeringErrorItem) and not (

                        type(item) is QEngineeringUnknownItem) and item.type != 'Notes' and not (

                        type(item) is QEngineeringEndBreakItem):

                    self._symbols.append(item)

                elif type(item) is QEngineeringLineNoTextItem:

                    lineNos.append(item)

                    if item.runs:

                        for run in item.runs:

                            start = [run.items[0]]

                            end = [run.items[-1]] if run.items[0] is not run.items[-1] else []

                            if type(start[0]) is QEngineeringOPCItem:

                                start_line_runs.insert(0, run)

                            else:

                                start_line_runs.append(run)

            for spec_break in spec_breaks:

                up_item = spec_break.up_stream

                down_item = spec_break.down_stream

                if issubclass(type(up_item), QEngineeringAbstractItem) and issubclass(type(down_item), QEngineeringAbstractItem) and \

                    up_item.owner is down_item.owner:

                    break_items_pair.append((up_item, down_item))

            line_list_row_datass = [] # [[[run, from item, to item], [run, from item, to item], ...], [[run, from item, to item], [run, from item, to item], ...], ...]

            while True:

                if len(start_line_runs) == 0:

                    break

                line_list_row_datas = [] # [[run, from item, to item], [run, from item, to item], ...]

                run = start_line_runs.pop(0)

                # row split if spec change in same run

                break_run_item_pairs = []

                for pair in break_items_pair:

                    if pair[0] in run.items and pair[1] in run.items:

                        break_run_item_pairs.append(pair)

                if break_run_item_pairs:

                    save_index = 0

                    for index in range(len(run.items)):

                        if index >= len(run.items) - 2:

                            break

                        for break_items in break_run_item_pairs:

                            if run.items[index] in break_items and run.items[index + 1] in break_items:

                                line_list_row_datas.append([run, run.items[save_index], run.items[index]])

                                save_index = index + 1

                    line_list_row_datas.append([run, run.items[save_index], run.items[index]])

                else:

                    line_list_row_datas.append([run, run.items[0], run.items[-1]])

                # for list row sequence, connected pipe list in a row

                for index in range(len(start_line_runs)):

                    if start_line_runs[index].items[0].is_connected(run.items[-1]):

                        connected_run = start_line_runs.pop(index)

                        start_line_runs.insert(0, connected_run)

                        break

                # row split if stream no change

                new_row_datas_index_infos = []

                for line_list_row_data_index in range(len(line_list_row_datas)):

                    new_row_datas = []

                    line_list_row_data = line_list_row_datas[line_list_row_data_index]

                    run = line_list_row_data[0]

                    start_index = run.items.index(line_list_row_data[1])

                    end_index = run.items.index(line_list_row_data[2])

                    pre_stream_no = line_list_row_data[1].stream_no

                    pre_index  = start_index

                    for index in range(start_index, end_index + 1):

                        if pre_stream_no != run.items[index].stream_no:

                            new_row_datas.append([run, run.items[pre_index], run.items[index - 1]])

                            pre_index = index

                            pre_stream_no = run.items[index].stream_no

                    if start_index != pre_index:

                        new_row_datas.append([run, run.items[pre_index], run.items[end_index]])

                    if new_row_datas:

                        new_row_datas_index_infos.append([line_list_row_data_index, new_row_datas])

                new_row_datas_index_infos.reverse()

                for new_row_datas_index_info in new_row_datas_index_infos:

                    line_list_row_datas.pop(new_row_datas_index_info[0])

                    new_row_datas_index_info[1].reverse()

                    for new_row_data in new_row_datas_index_info[1]:

                        line_list_row_datas.insert(new_row_datas_index_info[0], new_row_data)

                if line_list_row_datas:

                    line_list_row_datass.append(line_list_row_datas)

            return line_list_row_datass            

        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}"

            self.display_message.emit(MessageType.Error, message)

    def get_scene(self):

        # get scene for load data

        # now return mainwindow scene

        return self.parent().graphicsView.scene()

    '''

        @brief  accept dialog

    '''

    '''

    def accept(self):

        import uuid

        try:

            self.code_data = []

            self.isAccepted = False

            tabText = self.getTabText()    

            table = self.findTableWidget(tabText)

            for row in range(table.rowCount()):

                if table.isRowHidden(row):

                    continue

                else:

                    if not self.inst:

                        uid = table.item(row, 0).text() if table.item(row, 0).text() else str(uuid.uuid4())

                        code = table.item(row, 1).text() if table.item(row, 1) else ''

                        description = table.item(row, 2).text() if table.item(row, 2) is not None else ''

                        allowables = table.item(row, 3).text().split(',') if table.item(row, 3) is not None else []

                        if code:

                            self.code_data.append((uid, code, description, allowables))

                    else:

                        uid = table.item(row, 0).text() if table.item(row, 0).text() else str(uuid.uuid4())

                        code = table.item(row, 1).text().split(',') if table.item(row, 1) is not None else []

                        symbols = table.item(row, 2).text().split(',') if table.item(row, 3) is not None else []

                        attrs = table.item(row, 3).text().split(',') if table.item(row, 3) is not None else []

                        newCode = table.item(row, 4).text() if table.item(row, 1) else ''

                        expression = table.item(row, 5).text() if table.item(row, 1) else ''

                        priority = table.item(row, 6).text() if table.item(row, 1) else ''

                        texts = [[table.item(row, 1).text(), table.item(row, 2).text(), table.item(row, 3).text()], \

                                    [table.item(row, 4).text(), table.item(row, 5).text()]]

                        if True if len([text for text in texts[0] if text == '']) <= 2 and len([text for text in texts[1] if text == '']) <= 1 else False:

                            self.code_data.append((uid, code, symbols, attrs, newCode, expression, priority))

            self.isAccepted = True

            QDialog.accept(self)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)

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

    '''

    def reject(self):

        try:

            self.isAccepted = False

            QDialog.reject(self)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)

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

    def showDialog(self):

        self.show()

        self.exec_()