HYTOS

# coding: utf-8

""" This is engineering equipment 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 EngineeringConnectorItem import QEngineeringConnectorItem

from EngineeringAbstractItem import QEngineeringAbstractItem

from EngineeringTextItem import QEngineeringTextItem

from UserInputAttribute import UserInputAttribute

class QEngineeringEquipmentItem(SymbolSvgItem):

    """ This is engineering equipment item class """

    clicked = pyqtSignal(QGraphicsSvgItem)

    ZVALUE = 10

    EQUIP_COLUMN_LIST = None

    EQUIP_COLOR = None

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

        from SymbolAttr import SymbolProp

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

        self.setZValue(QEngineeringEquipmentItem.ZVALUE)

        self._properties = \

            { \

                SymbolProp(None, 'ITEM_NO', 'Tag No', Expression="self.tag_no"):None,

                SymbolProp(None, 'Desc', 'String', Expression="self.desc"):None

            }

        if QEngineeringEquipmentItem.EQUIP_COLUMN_LIST is None:

            from AppDocData import AppDocData

            appDocData = AppDocData.instance()

            QEngineeringEquipmentItem.EQUIP_COLUMN_LIST = appDocData.getColNames('EQUIPMENT_DATA_LIST')

    def texts(self):

        """ return text type of labels """

        from EngineeringTextItem import QEngineeringTextItem

        return sorted([x for x in self.associations() if issubclass(type(x), QEngineeringTextItem)], key=lambda attr: attr.loc[1])

    @property

    def tag_no(self):

        """ getter of tag_no """

        from QEngineeringTagNoTextItem import QEngineeringTagNoTextItem

        matches = [assoc for assoc in self.associations() if type(assoc) is QEngineeringTagNoTextItem]

        return matches[0].text() if matches else None

    @property

    def desc(self):

        """ getter of desc """

        from CodeTables import CodeTable

        try:

            if self.tag_no:

                matches = [value for value in CodeTable.instance('EqpTagNames').values if value[1] == self.tag_no]

                if matches: return matches[0][2]

        except Exception as ex:

            from App import App 

            from AppDocData import MessageType

            message = 'error occured({}) 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 ''

    '''

        @brief  connect attribute

        @author humkyung

        @date   2018.05.03

    '''

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

        from QEngineeringTagNoTextItem import QEngineeringTagNoTextItem

        if clear:

            self.clear_attr_and_assoc_item()

        # tag no text item will find owner itself

        '''

        try:

            rect = self.sceneBoundingRect()

            attrs = [attr for attr in attributes if type(attr) is QEngineeringTagNoTextItem]

            for attr in attrs:

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

                    self.add_assoc_item(attr)

                    attr.onwer = self

            # not have equipment name which is located inside equipment

            if not 'Tag No' in self._associations or not self._associations['Tag No']:

                minDist = None

                selected = None

                # get nearest text from equipment

                for attr in attrs:

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

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

                    dist = math.sqrt(dx*dx + dy*dy)

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

                        minDist = dist

                        selected = attr

                if selected is not None:

                    self.add_assoc_item(selected)

                    selected.onwer = self

        except Exception as ex:

            from App import App 

            from AppDocData import MessageType

            message = 'error occured({}) 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 equipment's color """

        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 QEngineeringEquipmentItem.EQUIP_COLOR:

            app_doc_data = AppDocData.instance()

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

            QEngineeringEquipmentItem.EQUIP_COLOR = configs[0].value if configs else QEngineeringAbstractItem.DEFAULT_COLOR

        return QEngineeringEquipmentItem.EQUIP_COLOR

        #else:

        #    return SymbolSvgItem.getColor(self)

    '''

        @brief      get attributes

        @author     humkyung

        @date       2018.06.14

    '''

    '''

    def getAttributes(self):

        _attrs = {}

        try:

            from AppDocData import AppDocData

            from EngineeringAbstractItem import QEngineeringAbstractItem

            from EngineeringTextItem import QEngineeringTextItem

            # 해당 Type의 attribute setting

            docData = AppDocData.instance()

            symbolAttrs = docData.getSymbolAttribute(self.type)

            _texts = self.texts()

            _symbols = self.symbols()

            for attr in symbolAttrs:

                if attr.AttributeType == 'Tag No' or attr.AttributeType == 'Size Text Item' or attr.AttributeType == 'Text Item' or attr.AttributeType == 'Valve Oper Code':

                    at = int(attr.AttrAt)

                    items = [text for text in _texts if QEngineeringAbstractItem.assoc_type(text) == attr.AttributeType]

                    if len(items) > at:

                        item = items[at]

                        _attrs[attr] = eval(attr.Expression) if attr.Expression else ''

                    else:

                        _attrs[attr] = ''

                elif attr.AttributeType == 'Symbol Item':

                    at = int(attr.AttrAt)

                    if len(_symbols) > at:

                        item = _symbols[at]

                        _attrs[attr] = eval(attr.Expression) if attr.Expression else ''

                    else:

                        _attrs[attr] = ''

                else:

                    matches = [prop for prop in self.attrs if prop.UID == attr.UID]

                    if len(matches) == 1:

                        _attrs[matches[0]] = self.attrs[matches[0]]

                    else:

                        _attrs[attr] = ''

        except Exception as ex:

            from App import App 

            from AppDocData import MessageType

            message = 'error occured({}) 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 _attrs

        '''

    def highlight(self, flag):

        """ highlight/unhighlight the equpment """

        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 occured({}) 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 equipment

        @author     humkyung

        @date       2018.05.09

    '''

    def toXml(self):

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

        try:

            node = SymbolSvgItem.toXml(self)

        except Exception as ex:

            from App import App 

            from AppDocData import MessageType

            message = 'error occured({}) 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 None

        return node 

    def toSql(self):

        """ convert equipment data to sql query """

        from AppDocData import AppDocData

        res = []

        appDocData = AppDocData.instance()

        cols = ['UID', 'ITEM_NO', 'PNID_NO']

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

        param = [str(self.uid), self.tag_no, appDocData.activeDrawing.name]

        """ save attributes to database """

        _attrs = self.getAttributes()

        for key,value in _attrs.items():

            cols.append(key.Attribute)

            values.append('?')

            param.append(value)

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

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

        cols = ['UID', 'Drawings_UID', 'Symbol_UID', 'X', 'Y', 'Width', 'Height', 'Rotation', 'Area', 'Owner', 'Connected', '[Supplied By]', \

                'SpecialItemTypes_UID', 'OriginIndex']

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

        param = [(str(self.uid), str(appDocData.activeDrawing.UID), str(self.dbUid), self.loc[0], self.loc[1], self.size[0], self.size[1], str(self.angle), 

        self.area, str(self.owner) if self.owner else None, \

        str(self.conns[0]) if self.conns else None, \

        self.prop('Supplied By'), \

        str(self.special_item_type) if self.special_item_type else None,\

        self.currentPointModeIndex)]

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

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

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

                param = [str(uuid.uuid4()), QEngineeringAbstractItem.assoc_type(assoc), str(self.uid), str(assoc.uid)]

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

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

        # 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))\

                        )

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

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

        # up to here

        return res

    '''

        @brief      return equip Data List

        @author     kyouho

        @date       2018.08.14

    '''

    def getEquipmentDataList(self):

        dataList = []

        try:

            from AppDocData import AppDocData

            docData = AppDocData.instance()

            attrs = self.attrs

            for index in range(len(QEngineeringEquipmentItem.EQUIP_COLUMN_LIST)):

                dataList.append('')

            dataList[0] = str(self.uid)

            dataList[14] = docData.imgName

            for attr in attrs:

                attrInfo = docData.getSymbolAttributeByUID(attr.UID)

                attrName = attrInfo[0]

                if QEngineeringEquipmentItem.EQUIP_COLUMN_LIST.count(attrName):

                    colIndex = QEngineeringEquipmentItem.EQUIP_COLUMN_LIST.index(attrName)

                    if type(attr) is UserInputAttribute:

                        dataList[colIndex] = attr.text if attr.text is not None else ''

                    elif type(attr) is QEngineeringTextItem:

                        dataList[colIndex] = attr.text()

                    else:

                        dataList[colIndex] = attr.uid

        except Exception as ex:

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

        return dataList