HYTOS

# coding: utf-8

"""

This is Engineering Instrument Item module

"""

import sys

import os

import math

from PyQt5.QtGui import *

from PyQt5.QtCore import *

from PyQt5.QtSvg import *

from PyQt5.QtWidgets import (QApplication, QGraphicsItem)

from SymbolSvgItem import SymbolSvgItem

from EngineeringAbstractItem import QEngineeringAbstractItem

from EngineeringConnectorItem import QEngineeringConnectorItem

from EngineeringTextItem import QEngineeringTextItem

from UserInputAttribute import UserInputAttribute

class QEngineeringInstrumentItem(SymbolSvgItem):

    """ This is Engineering Instrument Item class """

    clicked = pyqtSignal(QGraphicsSvgItem)

    INST_COLUMN_LIST = None

    INST_COLOR = None

    '''

    '''

    def __init__(self, path, uid=None, flip=0):

        SymbolSvgItem.__init__(self, None, path, uid, flip=flip)

        self._measuredVairableCode = None

        self._typeModifier = None

        self._tagSeqNo = None

        self._tagSuffix = None

        if QEngineeringInstrumentItem.INST_COLUMN_LIST is None:

            from AppDocData import AppDocData

            appDocData = AppDocData.instance()

            QEngineeringInstrumentItem.INST_COLUMN_LIST = appDocData.getColNames('INSTRUMENT_DATA_LIST')

    '''

        @brief  getter of measured variable code

        @author humkyung

        @date   2018.05.06

    '''

    @property

    def measuredVariableCode(self):

        return self._measuredVairableCode

    '''

        @brief  setter of measured variable code

        @author humkyung

        @date   2018.05.06

    '''

    @measuredVariableCode.setter

    def measuredVariableCode(self, value):

        self._measuredVairableCode = value

    '''

        @brief  getter of type modifier

        @author humkyung

        @date   2018.05.06

    '''

    @property

    def typeModifier(self):

        return self._typeModifier

    '''

        @brief  setter of type modifier

        @author humkyung

        @date   2018.05.06

    '''

    @typeModifier.setter

    def typeModifier(self, value):

        self._typeModifier = value

    '''

        @brief  getter of tag seq no

        @author humkyung

        @date   2018.05.06

    '''

    @property

    def tagSeqNo(self):

        return self._tagSeqNo

    '''

        @brief  setter of tag seq no

        @author humkyung

        @date   2018.05.06

    '''

    @tagSeqNo.setter

    def tagSeqNo(self, value):

        self._tagSeqNo = value

    '''

        @brief  getter of tag suffix

        @author humkyung

        @date   2018.05.06

    '''

    @property

    def tagSuffix(self):

        return self._tagSuffix

    '''

        @brief  setter of tag suffix

        @author humkyung

        @date   2018.05.06

    '''

    @tagSuffix.setter

    def tagSuffix(self, value):

        self._tagSuffix = value

    def highlight(self, flag):

        """ highlight/unhighlight the instrument """

        try:

            self.hover = flag

            self.update()

            for assoc in self.associations():

                assoc.highlight(flag)

            for connector in self.connectors:

                connector.highlight(flag)

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

        """ return instrument's color 2019.04.24 adde by humkyung """

        from AppDocData import AppDocData

        from DisplayColors import DisplayColors

        from DisplayColors import DisplayOptions

        from EngineeringAbstractItem import QEngineeringAbstractItem

        from EngineeringLineItem import QEngineeringLineItem

        if DisplayOptions.DisplayByLineType == DisplayColors.instance().option:

            if self.hover:

                return SymbolSvgItem.HOVER_COLOR

            elif not QEngineeringInstrumentItem.INST_COLOR:

                app_doc_data = AppDocData.instance()

                configs = app_doc_data.getConfigs('Instrument', 'Color')

                QEngineeringInstrumentItem.INST_COLOR = configs[

                    0].value if configs else QEngineeringAbstractItem.DEFAULT_COLOR

            return QEngineeringInstrumentItem.INST_COLOR

        else:

            return SymbolSvgItem.getColor(self)

    '''

        @brief  connect attribute

        @author humkyung

        @date   2018.05.06

    '''

    def connectAttribute(self, attributes, clear=True):

        from AppDocData import AppDocData

        try:

            if clear:

                if not self.clear_attr_and_assoc_item():

                    return

            rect = self.sceneBoundingRect()

            minDist = None

            selected = None

            configs = AppDocData.instance().getConfigs('Range', 'Detection Ratio')

            ratio = float(configs[0].value) if 1 == len(configs) else 1.5

            dist = (self.sceneBoundingRect().height() + self.sceneBoundingRect().width()) * ratio / 2

            center = self.sceneBoundingRect().center()

            for attr in attributes:

                if issubclass(type(attr), QEngineeringTextItem):

                    if rect.contains(attr.center()):

                        if self.add_assoc_item(attr):

                            attr.owner = self  # set owner of text

                elif issubclass(type(attr), SymbolSvgItem):

                    dx = attr.center().x() - center.x()

                    dy = attr.center().y() - center.y()

                    offset = (attr.sceneBoundingRect().width() + attr.sceneBoundingRect().height()) / 4

                    length = math.sqrt(dx * dx + dy * dy) - offset

                    if (length < dist) and (minDist is None or length < minDist):

                        minDist = length

                        selected = attr

            if selected is not None:

                self.add_assoc_item(selected)

        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)

    '''

        @brief  generate xml code for attribute

        @author humkyung

        @date   2018.05.06

    '''

    def toXmlAsAttribute(self, parentNode):

        from xml.etree.ElementTree import Element, SubElement, dump, ElementTree

        try:

            attrNode = Element('ATTRIBUTE')

            uidNode = Element('UID')

            uidNode.text = str(self.uid)

            attrNode.append(uidNode)

            nameNode = Element('NAME')

            nameNode.text = 'Measured Variable Code'

            attrNode.append(nameNode)

            valueNode = Element('VALUE')

            valueNode.text = self.measuredVariableCode

            attrNode.append(valueNode)

            parentNode.append(attrNode)

        except Exception as ex:

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

                                                      sys.exc_info()[-1].tb_lineno))

        try:

            attrNode = Element('ATTRIBUTE')

            uidNode = Element('UID')

            uidNode.text = str(self.uid)

            attrNode.append(uidNode)

            nameNode = Element('NAME')

            nameNode.text = 'Type Modifier'

            attrNode.append(nameNode)

            valueNode = Element('VALUE')

            valueNode.text = self.typeModifier

            attrNode.append(valueNode)

            parentNode.append(attrNode)

        except Exception as ex:

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

                                                      sys.exc_info()[-1].tb_lineno))

        try:

            attrNode = Element('ATTRIBUTE')

            uidNode = Element('UID')

            uidNode.text = str(self.uid)

            attrNode.append(uidNode)

            nameNode = Element('NAME')

            nameNode.text = 'Tag Seq No'

            attrNode.append(nameNode)

            valueNode = Element('VALUE')

            valueNode.text = self.tagSeqNo

            attrNode.append(valueNode)

            parentNode.append(attrNode)

        except Exception as ex:

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

                                                      sys.exc_info()[-1].tb_lineno))

        try:

            attrNode = Element('ATTRIBUTE')

            uidNode = Element('UID')

            uidNode.text = str(self.uid)

            attrNode.append(uidNode)

            nameNode = Element('NAME')

            nameNode.text = 'Tag Suffix'

            attrNode.append(nameNode)

            valueNode = Element('VALUE')

            valueNode.text = self.tagSuffix

            attrNode.append(valueNode)

            parentNode.append(attrNode)

        except Exception as ex:

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

                                                      sys.exc_info()[-1].tb_lineno))

    def toSql_return_separately(self):

        """ convert instrument data to sql query """

        import uuid

        from AppDocData import AppDocData

        res = []

        resLater = []

        res.append(self.toSql_Components())

        _attrs = self.getAttributes()

        if _attrs:

            cols = ['UID', 'Components_UID', 'SymbolAttribute_UID', 'Value']

            values = ['?', '?', '?', '?']

            params = []

            for key in _attrs.keys():

                params.append((str(uuid.uuid4()), str(self.uid), str(key.UID), str(_attrs[key])))

            sql = 'insert into Attributes({}) values({})'.format(','.join(cols), ','.join(values))

            res.append((sql, tuple(params)))

        if self.associations():

            cols = ['UID', '[Type]', 'Components_UID', 'Association']

            values = ['?', '?', '?', '?']

            params = []

            for assoc in self.associations():

                params.append(

                    (str(uuid.uuid4()), QEngineeringAbstractItem.assoc_type(assoc), str(self.uid), str(assoc.uid)))

            sql = 'insert into Associations({}) values({})'.format(','.join(cols), ','.join(values))

            resLater.append((sql, tuple(params)))

        # save connectors to database

        if self.connectors:

            cols = ['Components_UID', '[Index]', 'X', 'Y', 'Connected', 'Connected_At']

            values = ['?', '?', '?', '?', '?', '?']

            params = []

            index = 1

            for connector in self.connectors:

                params.append( \

                    (  # str(connector.uid),

                        str(self.uid), index, connector.connectPoint[0], connector.connectPoint[1], \

                        str(connector.connectedItem.uid) if connector.connectedItem else None, \

                        str(connector._connected_at)) \

                    )

                index += 1

            sql = 'insert into Points({}) values({})'.format(','.join(cols), ','.join(values))

            resLater.append((sql, tuple(params)))

        # up to here

        return res, resLater

    '''

        @brief      return inst Data List

        @author     kyouho

        @date       2018.08.14

    '''

    def getInstrumentDataList(self):

        dataList = []

        try:

            from AppDocData import AppDocData

            docData = AppDocData.instance()

            attrs = self.getAttributes()

            for index in range(len(QEngineeringInstrumentItem.INST_COLUMN_LIST)):

                dataList.append('')

            dataList[0] = str(self.uid)

            dataList[13] = docData.imgName

            for key in attrs.keys():

                attrInfo = docData.getSymbolAttributeByUID(key.UID)

                attrName = attrInfo.Attribute

                if attrName in QEngineeringInstrumentItem.INST_COLUMN_LIST:

                    colIndex = QEngineeringInstrumentItem.INST_COLUMN_LIST.index(attrName)

                    dataList[colIndex] = attrs[key]

        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)

        return dataList