HYTOS

# coding: utf-8

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 EngineeringTextItem import QEngineeringTextItem

from UserInputAttribute import UserInputAttribute

class QEngineeringEquipmentItem(SymbolSvgItem):

    clicked = pyqtSignal(QGraphicsSvgItem)

    ZVALUE = 10

    EQUIP_COLUMN_LIST = None

    '''

    '''

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

        SymbolSvgItem.__init__(self, path, uid)

        self.setZValue(QEngineeringEquipmentItem.ZVALUE)

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

    '''

        @brief  connect attribute

        @author humkyung

        @date   2018.05.03

    '''

    def connectAttribute(self, attributes):

        from QEngineeringTagNoTextItem import QEngineeringTagNoTextItem

        self._associations.clear()

        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)

            if not 'Text Item' in self._associations or not self._associations['Text Item']:

                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)

        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      get attributes

        @author     humkyung

        @date       2018.06.14

    '''

    def getAttributes(self):

        _attrs = {}

        try:

            from AppDocData import AppDocData

            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 == 'Text Item':

                    at = int(attr.AttrAt)

                    if len(_texts) > at:

                        item = _texts[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:

                    _attrs[attr] = ''#self.attrs[attr[1]] if attr[1] in self.attrs.keys() else ''

        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

    '''

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

            self.toXmlAsAttribute(node)

        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 node 

    '''

        @brief  generate xml code for attribute

        @author humkyung

        @date   2018.05.03

    '''

    def toXmlAsAttribute(self, parentNode):

        for attr in self.texts():

            parentNode.append(attr.toXml(self, None))

    def toSql(self):

        """

        convert equipment data to sql query

        """

        from AppDocData import AppDocData

        res = []

        appDocData = AppDocData.instance()

        cols = ['UID', 'PNID_NO']

        values = ['?','?']

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

        _attrs = self.getAttributes()

        for key in _attrs.keys():

            cols.append(key.Attribute)

            values.append('?')

            param.append(_attrs[key])

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

        '''

        for key in _attrs.keys():

            if key.Attribute in QEngineeringEquipmentItem.EQUIP_COLUMN_LIST:

                cols.append(key.Attribute)

                values.append('?')

                param.append(_attrs[key])

            else:

                _cols = ['Symbol_UID', 'SymbolAttribute_UID', 'Value', 'Drawings_Name']

                _values = ['?', '?', '?', '?']

                _param = [str(self.uid), key.UID, _attrs[key], appDocData.activeDrawing.name]

                _sql = 'insert or replace into Attributes({}) values({})'.format(','.join(_cols), ','.join(_values))

                res.append((_sql, tuple(_param)))

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

        res.insert(0, (sql, tuple(param)))

        return res

        '''

        return (sql, tuple(param))

    '''

        @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.attribute)

                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