HYTOS

from PyQt5.QtCore import *

from SymbolSvgItem import SymbolSvgItem

import asyncio

import aiohttp

from App import App

def strToBool(s):

    return s.upper() == "TRUE"

class MappingsDelegate(QStyledItemDelegate):

    def __init__(self, parent=None):

        QStyledItemDelegate.__init__(self, parent)

    def createEditor(self, parent, option, index):

        editor = None

        #Categoy

        if index.column() == 2:

            phases = ["Maximum Flowrate Case", "Normal Flowrate Case", "Minimum Flowrate Case"]

            editor = QComboBox(parent)

            editor.addItems([str(phases[_index]) for _index in range(len(phases))])

        return editor if editor else super(MappingsDelegate, self).createEditor(parent, option, index)

        self.ui.comboBox_select_PAP_Project.currentIndexChanged.connect(self.connect_api)

        self.send_api(end_point = "/api/Projects", method= "GET")

        self.data_load()

        #self.ui.tableView_upload_item_list.resizeColumnsToContents()

        #self.ui.tableView_upload_item_list.horizontalHeader().setSectionResizeMode(

        #    self.ui.tableView_upload_item_list.horizontalHeader().count() - 1, QtWidgets.QHeaderView.Stretch)

        #self.ui.tableView_upload_item_list.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents);

        self.ui.tableView_upload_item_list.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)

    def data_load(self):

        self.calculation_calse = ["Maximum Flowrate Case", "Normal Flowrate Case", "Minimum Flowrate Case"]

        self.ui.comboBox_Calculation_Case.addItems(self.calculation_calse)

        self.graphicsView = App.mainWnd().graphicsView

        items = [item for item in self.graphicsView.scene.items() if type(item) is SymbolSvgItem]

        if items:

            self.data_frame_to_ui_configuration(items)

    def data_frame_to_ui_configuration(self, items):

        headerColumn = ["Item Type.", "Item Tag No." ,"Data Case"]

        # for the table model

        value_model = QtGui.QStandardItemModel()

        # set table headers

        value_model.setColumnCount(len(headerColumn))

        value_model.setHorizontalHeaderLabels(headerColumn)

        # fill table model data

        for row_idx in range(0, len(items)):  # len(data_frame.values)

            row = list()

            for col_idx in range(len(headerColumn)):

                if headerColumn[col_idx] == headerColumn[0] :

                    value = items[row_idx].type

                if headerColumn[col_idx] == headerColumn[1] :

                    value = items[row_idx].tag_no

                val = QtGui.QStandardItem(value)

                val.setEditable(True)

                row.append(val)

            value_model.appendRow(row)

        # Sort Filter Proxy Set Model

        self.ui.tableView_upload_item_list.setModel(value_model)

        self.model = value_model

        # Sort Filter Proxy Set Model

        # Set Selection Model

        self.selection_model = self.ui.tableView_upload_item_list.selectionModel()

        # Set Selection Model

        self.ui.tableView_upload_item_list.setSortingEnabled(True)

        self.ui.tableView_upload_item_list.setItemDelegate(MappingsDelegate(self.ui.tableView_upload_item_list))

    def send_api(self, end_point, method):

        url = app_doc_data.API_HOST + end_point

    def connect_api(self, index):

        #self.ui.comboBox_select_PAP_Project.setEnabled(False)

        self.startAnimation()

        QTimer.singleShot(500, self.connections)

    def connections(self):

        result = "false"

        projectNo = self.ui.comboBox_select_PAP_Project.currentText()

        try:

            asyncio.run(self.run_connection(projectNo))

        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)

    async def run_connection(self, projectNo):

        task = asyncio.create_task(self.connection(projectNo))

        result = await task

        self.ui.comboBox_select_PAP_Project.setEnabled(True)

        if strToBool(str(result)):

            QTimer.singleShot(500, self.doneAnimation)

        else:

            QTimer.singleShot(500, self.closeAnimation)

    @asyncio.coroutine

    async def connection(self,projectNo):

        app_doc_data = AppDocData.instance()

        end_point = f"{app_doc_data.API_HOST}/api/Projects/Connection?ProjectName={projectNo}"

        async with aiohttp.ClientSession() as session:

            async with session.get(f'{end_point}') as resp:

                return await resp.json()