HYTOS

# -*- coding: utf-8 -*-

"""This is Equipment module"""

import sys

from PyQt5 import QtCore, QtGui, QtWidgets

from PyQt5.QtWidgets import *

from PyQt5.QtGui import QMovie

from PyQt5.QtCore import *

from SymbolSvgItem import SymbolSvgItem

import os

import asyncio

import aiohttp

from App import App

import Export_To_PAP_UI

import math

import requests

import json

from AppDocData import AppDocData

def is_float(s):

    try:

        if s:

            float(s)

            return True

        else:

            return False

    except ValueError:

        return False

def strToBool(s):

    return s.upper() == "TRUE"

def is_blank(s):

    return not (s and s.strip())

def is_not_blank(s):

    return bool(s and s.strip())

def convert_to_fixed_point(value):

    if is_float(str(value)):

        tokens = f"{float(value):.10f}".split('.')

        if len(tokens) == 2:

            # 소수점 아래가 있을 경우 소수점 아래의 trailing zero를 제거한다.

            if is_blank(tokens[1].rstrip('0')):

                return tokens[0]

            else:

                tokens[1] = tokens[1].rstrip('0')

                return '.'.join(tokens)

        else:

            return tokens[0]

    else:

        return value

class MappingsDelegate(QStyledItemDelegate):

    def __init__(self, parent=None):

        QStyledItemDelegate.__init__(self, parent)

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

        editor = None

        item = parent.parent().model().itemFromIndex(parent.parent().model().index(index.row(), 0))

        if index.column() == 2:

            datacase = []

            editor = QComboBox(parent)

            if item.text() == "Pump":

                datacase = ["Rated Flow Case", "Maximum Flow Case","N/A"]

            elif item.text() == "Compressor":

                datacase = ["Design Case", "N/A"]

                editor.setEditable(True)

            elif item.text() == "Valve":

                datacase = ["Maximum Flowrate Case", "Normal Flowrate Case", "Minimum Flowrate Case","N/A"]

            else:

                pass

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

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

class QExport_To_PAP(QDialog):

    def __init__(self):

        QDialog.__init__(self)

        self.ui = Export_To_PAP_UI.Ui_Dialog()

        self.ui.setupUi(self)

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

        self.ui.buttonBox.button(QDialogButtonBox.Cancel).setIcon(QtGui.QIcon(':/images/Cancel.svg'))

        self.load_movie = QMovie(":/images/loader.gif")

        self.close_movie = QMovie(":/images/close.png")

        self.done_movie = QMovie(":/images/done.png")

        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 startAnimation(self):

        self.close_movie.stop()

        self.done_movie.stop()

        self.ui.label_loading.setMovie(self.load_movie)

        self.load_movie.start()

        # Stop Animation(According to need)

    def doneAnimation(self):

        self.load_movie.stop()

        self.close_movie.stop()

        self.ui.label_loading.setMovie(self.done_movie)

        self.done_movie.start()

    def closeAnimation(self):

        self.load_movie.stop()

        self.done_movie.stop()

        self.ui.label_loading.setMovie(self.close_movie)

        self.close_movie.start()

    def send_api(self, end_point, method):

        app_doc_data = AppDocData.instance()

        url = app_doc_data.API_HOST + end_point

        headers = {'Content-Type': 'application/json', 'charset': 'UTF-8', 'Accept': '*/*'}

        try:

            if method == 'GET':

                response = requests.get(url, headers=headers)

                if response.status_code == 200:

                    json_objects = json.loads(response.text)

                    for json_object in json_objects:

                        self.ui.comboBox_select_PAP_Project.addItem(json_object['Name'])

        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 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()

    def accept(self):

        QDialog.accept(self)

    def reject(self):

        QDialog.reject(self)