HYTOS

# coding: utf-8

""" This is engineering line no text item module """

import os.path

import sys

import copy

try:

    from PyQt5.QtCore import Qt, QPointF, QRectF, pyqtSignal, QT_VERSION_STR, QRect

    from PyQt5.QtGui import QImage, QPixmap, QPainterPath, QBrush, QPen, QTransform, QFont

    from PyQt5.QtWidgets import QGraphicsView, QGraphicsScene, QFileDialog, QGraphicsItem, QAbstractGraphicsShapeItem, QGraphicsTextItem

except ImportError:

    try:

        from PyQt4.QtCore import Qt, QRectF, pyqtSignal, QT_VERSION_STR, QRect

        from PyQt4.QtGui import QGraphicsView, QGraphicsScene, QImage, QPixmap, QPainterPath, QFileDialog, QFont

    except ImportError:

        raise ImportError("ImageViewerQt: Requires PyQt5 or PyQt4.")

from EngineeringPolylineItem import QEngineeringPolylineItem

from GraphicsBoundingBoxItem import QGraphicsBoundingBoxItem

from UserInputAttribute import UserInputAttribute

from OcrResultDialog import QOcrResultDialog

from AppDocData import AppDocData

from EngineeringTextItem import QEngineeringTextItem

from TextInfo import TextInfo

lineColumnList = ['UID', 'LINE_SIZE', 'LINE_SYMBOL', 'LINE_NO', 'LINE_CLASS', 'LINE_ROUTING_FROM', 'LINE_ROUTING_TO', 'SERVICE_FLUID', 'SERVICE_DENSITY', 'SERVICE_STATE', 'OPERATION_CONDITION_TEMP', 'OPERATION_CONDITION_PRESS', 'DESIGN_CONDITION_TEMP', 'DESIGN_CONDITION_PRESS', 'TEST_CONDITION_TEMP', 'TEST_CONDITION_PRESS', 'INSUL_CODE', 'PAINT_CODE', 'NDE_CODE', 'PWHT', 'PNID_NO']

class QEngineeringLineNoTextItem(QEngineeringTextItem):

    '''

        @history    18.05.14    Jeongwoo    Add variable self.runs

                    humkyung 2018.07.09 add stream no

    '''

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

        from SymbolAttr import SymbolProp

        from EngineeringFreezeItem import QEngineeringFreezeItem

        QEngineeringTextItem.__init__(self, uid, parent)

        self._properties = {SymbolProp(None, 'From', 'Comp Item'):None, SymbolProp(None, 'To', 'Comp Item'):None}#, SymbolProp(None, 'Freeze', 'Boolean'):False}

        self._runs = []

        """ create freeze control """

        #self.freeze_item = QEngineeringFreezeItem(-QEngineeringFreezeItem.FREEZE_SIZE*0.5, -QEngineeringFreezeItem.FREEZE_SIZE*0.5, QEngineeringFreezeItem.FREEZE_SIZE, QEngineeringFreezeItem.FREEZE_SIZE)

        #self.freeze_item.setParentItem(self)

        #self.freeze_item.setZValue(self.zValue() + 1)

        #self.freeze_item.setPen(Qt.black)

    @property

    def Size(self):

        """ return line no's size """

        attrs = self.getAttributes()

        matches = [value for attr,value in attrs.items() if attr.Attribute.upper() == 'NOMINALDIAMETER']

        return matches[0] if matches else None

    def empty(self):

        """ return True if run is empty else return False """

        return False if self._runs else True

    def setVisible(self, visible):

        """ override visible value """

        super(QEngineeringTextItem, self).setVisible(visible)

        for run in self.runs:

            run.visible = visible

    '''

        @brief  getter of runs

        @author humkyung

        @date   2018.05.11

    '''

    @property

    def runs(self):

        return self._runs

    '''

        @brief  setter of runs

        @author humkyung

        @date   2018.05.11

    '''

    @runs.setter

    def runs(self, value):

        self._runs = value

    def hoverEnterEvent(self, event):

        """ highlight line no text and run's item """

        self.hover = True

        self.update()

        for run in self.runs:

            for item in run.items:

                item.hoverEnterEvent(event)

    def hoverLeaveEvent(self, event):

        """ unhighlight line no text and run's item """

        self.hover = False

        self.update()

        for run in self.runs:

            for item in run.items:

                item.hoverLeaveEvent(event)

    def keyPressEvent(self, event): 

        """ reverse line routine when user press 'C' key """

        if event.key() == Qt.Key_C:

            self.reverse()

        QEngineeringTextItem.keyPressEvent(self, event)

    def update_flow_mark(self, position, minLength):

        """ update line flow mark """

        import math

        from EngineeringLineItem import QEngineeringLineItem

        allowed_error_radian = 0.09

        try:

            for run in self.runs:

                pre = None

                preRadian = None

                for item in run.items:

                    if pre is None and type(item) is QEngineeringLineItem and (item._lineType == 'Primary' or item._lineType == 'Secondary') and item.length() > minLength:

                        pre = item

                        start = item.line().p1()

                        end = item.line().p2()

                        _dir = [(end.x() - start.x())/item.length(), (end.y() - start.y())/item.length()]

                        radian = math.atan2(_dir[1], _dir[0]) - math.pi / 2

                        preRadian = radian if radian >= 0 else radian + 2 * math.pi

                        preRadian = abs(preRadian - math.pi)

                    elif pre and type(pre) is QEngineeringLineItem and type(item) is QEngineeringLineItem and (item._lineType == 'Primary' or item._lineType == 'Secondary'):

                        start = item.line().p1()

                        end = item.line().p2()

                        _dir = [(end.x() - start.x())/item.length(), (end.y() - start.y())/item.length()]

                        radian = math.atan2(_dir[1], _dir[0]) - math.pi / 2

                        currRadian = radian if radian >= 0 else radian + 2 * math.pi

                        currRadian = abs(currRadian - math.pi)

                        if abs(currRadian - preRadian) > allowed_error_radian:

                            # insert flow mark at pre line

                            if pre.length() > minLength:

                                #if str(pre.uid) == '62edfbe5-29fd-49af-840b-6dce051e04d1':

                                    #print(math.atan2(preDir[0], preDir[1]) - math.pi / 2)

                                    #print(currRadian)

                                    #print(preRadian)

                                pre.flowMark = position

                                pre.update_arrow()

                            pre = item

                            preRadian = currRadian

                if pre and type(item) is QEngineeringLineItem and (item._lineType == 'Primary' or item._lineType == 'Secondary') and item.length() > minLength:

                    pre.flowMark = position

                    pre.update_arrow()

        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 paint(self, painter, options=None, widget=None):

        QEngineeringTextItem.paint(self, painter, options, widget)

        if self.freeze_item is None:

            from EngineeringFreezeItem import QEngineeringFreezeItem

            self.freeze_item = QEngineeringFreezeItem(0, 0, QEngineeringFreezeItem.FREEZE_SIZE, QEngineeringFreezeItem.FREEZE_SIZE)

            self.freeze_item.setParentItem(self)

            self.freeze_item.setZValue(self.zValue() + 1)

            self.freeze_item.setPen(Qt.black)

    """

    def reverse(self):

        """ reverse line routine """

        if self.runs:

            self.runs[0].reverse()

            _from = self.prop('From')

            _to = self.prop('To')

            self.set_property('From', _to)

            self.set_property('To', _from)

    def getLongestTwoPoints(self, pts):

        import math

        res = [None, None]

        maxDistance = None

        for i in range(len(pts)):

            for j in range(i+1, len(pts)):

                dx = pts[i][0] - pts[j][0]

                dy = pts[i][1] - pts[j][1]

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

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

                    maxDistance = dist

                    res[0] = pts[i]

                    res[1] = pts[j]

        return res

    '''

        @brief      set attribute

        @author     humkyung

        @date       2018.07.20

    '''

    def set_attrib(self, attrib, value):

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

        if len(matches) == 1:

            self.attrs[matches[0]] = value

        else:

            self.attrs[attrib] = value

    def removeSelfAttr(self, attributeName):

        pass

    '''

        @brief      get attribute

        @author     kyouho

        @date       2018.09.06

    '''

    def getLineNoAttributes(self, _attrs=None):

        from SymbolAttr import SymbolAttr

        from Configs import LineNoConfig

        if _attrs is None:

            _attrs = {}

        try:

            docData = AppDocData.instance()

            line_no_configs = LineNoConfig.instance()

            config = None

            if line_no_configs:

                for line_no_config in line_no_configs:

                    item = line_no_config.parse(self.text())

                    if item[0]:

                        config = line_no_config

                        break

            else:

                item = (False,)

            # Line No 부분

            if item[0]:

                attr = SymbolAttr()

                attr.Attribute = 'LINE NO'

                attr.DisplayAttribute = 'Line No'

                attr.AttributeType = 'String'

                attr.IsProp = 5

                _attrs[attr] = self.text()

                result = item[1]

                configs = config.value.split(self.delimiter)

                props = docData.getLineProperties()

                for prop in props:

                    if prop.UID in configs:

                        for i in range(len(configs)):

                            if prop.UID == configs[i]:

                                _attrs[prop] = result[i]

                                break

                    else:

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

                        if len(matches) == 1:

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

                        #else:

                        #    _attrs[prop] = ''

        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 _attrs

    @staticmethod

    def from_database(component):

        """ get line no item from database """

        import uuid

        from AppDocData import AppDocData

        from TextItemFactory import TextItemFactory

        from SymbolAttr import SymbolAttr

        item = None

        try:

            x = float(component['X'])

            y = float(component['Y'])

            width = float(component['Width']) if component['Width'] is not None else 0

            height = float(component['Height']) if component['Height'] is not None else 0

            angle = float(component['Rotation']) if component['Rotation'] is not None else 0

            text = component['Value']

            textInfo = TextInfo(text, x, y, width, height, angle)

            connline = component['Connected'] if component['Connected'] is not None else None

            item = TextItemFactory.instance().createTextItem(textInfo)

            if item is not None:

                item.setVisible(False)

                for key in item._properties.keys():

                    item._properties[key] = key.parse_value(component[key.Attribute])

                app_doc_data = AppDocData.instance()

                # get associations 

                associations = app_doc_data.get_component_associations(component['UID'])

                if associations:

                    for assoc in associations:

                        _attrType = assoc['Type']

                        if not _attrType in item._associations:

                            item._associations[_attrType] = []

                        item._associations[_attrType].append(

                            uuid.UUID(assoc['Association']) if assoc['Association'] != 'None' else None)

                # up to here

                attrs = app_doc_data.get_component_attributes(component['UID'])

                for _attr in attrs:

                    attr = SymbolAttr.from_record(_attr)

                    item.attrs[attr] = _attr['Value']

                item.uid = uuid.UUID(component['UID'])

                item.loc = [x, y]

                item.size = (width, height)

                item.angle = angle

                item.setToolTip('<b>{}</b><br>LINE NO={}'.format(str(item.uid), text))

                """ apply freeze value """

                #item.freeze_item.update_freeze(item.prop('Freeze'))

                if connline is not None:

                    item.conns.append(connline)

        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 None

        return item

    @staticmethod

    def fromXml(node):

        """ generate EngineeringLineNoTextItem from xml node """

        import uuid

        from TextItemFactory import TextItemFactory

        from SymbolAttr import SymbolAttr

        item = None

        try:

            location = node.find('LOCATION').text if node.find('LOCATION') is not None else '0,0'

            x = float(location.split(',')[0])

            y = float(location.split(',')[1])

            width = float(node.find('WIDTH').text) if node.find('WIDTH') is not None else 0

            height = float(node.find('HEIGHT').text) if node.find('HEIGHT') is not None else 0

            angle = float(node.find('ANGLE').text) if node.find('ANGLE') is not None else 0

            text = node.find('TEXT').text

            textInfo = TextInfo(text, x, y, width, height, angle)

            connline = node.find('CONNLINE').text if node.find('CONNLINE') is not None else None

            item = TextItemFactory.instance().createTextItem(textInfo)

            if item is not None:

                for prop_node in node.iter('PROPERTY'):

                    matches = [prop for prop in item._properties.keys() if prop.Attribute == prop_node.attrib['Attribute']]

                    if matches:

                        item._properties[matches[0]] = matches[0].parse_value(prop_node.text)

                for attr_node in node.iter('ATTRIBUTE'):

                    attr = SymbolAttr.fromXml(attr_node)

                    item.attrs[attr] = attr_node.text

                item.uid = uuid.UUID(node.find('UID').text)

                item.loc = [x, y]

                item.size = (width, height)

                item.angle = angle

                item.setToolTip('<b>{}</b><br>LINE NO={}'.format(str(item.uid), text))

                """ apply freeze value """

                #item.freeze_item.update_freeze(item.prop('Freeze'))

                if connline is not None:

                    item.conns.append(connline)

        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 None

        return item

    '''

        @brief      generate xml code

        @author     humkyung

        @date       2018.04.23

        @history    humkyung 2018.05.02 write symbol's attribute

                    humkyung 2018.05.16 write run information to xml

    '''

    def toXml(self):

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

        from EngineeringLineItem import QEngineeringLineItem

        from SymbolSvgItem import SymbolSvgItem

        try:

            docData = AppDocData.instance()

            configs = docData.getConfigs('Line No', 'Delimiter')

            delimiter = configs[0].value if 1 == len(configs) else '-'

            lineNoconfigs = docData.getConfigs('Line No', 'Configuration')

            node = Element('LINE_NO')

            uidNode = Element('UID')

            uidNode.text = str(self.uid)

            node.append(uidNode)

            textNode = Element('TEXT')

            textNode.text = self.text() 

            node.append(textNode)

            locNode = Element('LOCATION')

            locNode.text = '{},{}'.format(self.loc[0], self.loc[1])

            node.append(locNode)

            widthNode = Element('WIDTH')

            widthNode.text = str(self.size[0])

            node.append(widthNode)

            heightNode = Element('HEIGHT')

            heightNode.text = str(self.size[1])

            node.append(heightNode)

            angleNode = Element('ANGLE')

            angleNode.text = str(self.angle)

            node.append(angleNode)

            areaNode = Element('AREA')

            areaNode.text = self.area

            node.append(areaNode)

            for run in self.runs:

                node.append(run.toXml())

            properties_node = Element('PROPERTIES')

            for prop,value in self.properties.items():

                prop_node = prop.toXml()

                prop_node.text = str(value) if value else ''

                properties_node.append(prop_node)

            node.append(properties_node)

            _attrs = self.getAttributes()

            for key in _attrs.keys():

                if key.UID is not None:

                    attrNode = key.toXml()

                    attrNode.text = str(_attrs[key])

                    node.append(attrNode) 

            if self.conns:

                connNode = Element('CONNLINE')

                connNode.text = str(self.conns[0].uid) if hasattr(self.conns[0], 'uid') else str(self.conns[0])

                node.append(connNode)

            sceneNode = Element('SCENE')

            sceneNode.text = str(self.sceneBoundingRect()).replace('PyQt5.QtCore.QRectF(', '').replace(' ', '').replace(')', '')

            node.append(sceneNode)

        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 None

        return node 

    def end_break(self):

        '''

            @brief  end break check

            @author euisung

            @date   2019.05.07

            @history    2019.05.19  euisung    can cover at both end that contact other line's middle

                        2019.05.19  euisung    no more used integrated with linetracer

        '''

        from EngineeringLineItem import QEngineeringLineItem

        from SymbolSvgItem import SymbolSvgItem

        from AppDocData import AppDocData

        end_breaks = []

        try:

            docdata = AppDocData.instance()

            line_from = self.prop('From')

            line_to = self.prop('To')

            end_break_names = docdata.getSymbolListByType('type', 'End Break')

            if len(end_break_names) is 0:

                return end_breaks

            svgFileName = end_break_names[0].sName

            symbol = AppDocData.instance().getSymbolByQuery('name', svgFileName)

            svgFilePath = os.path.join(AppDocData.instance().getCurrentProject().getSvgFilePath(), symbol.getType(), svgFileName+'.svg')

            for line_end in [line_from, line_to]:

                for connector in line_end.connectors:

                    if connector.connectedItem is not None and connector.connectedItem.owner is not self:

                        end_break = SymbolSvgItem.createItem(symbol.getType(), None, svgFilePath)

                        pt = [connector.center()[0] - float(symbol.getOriginalPoint().split(',')[0]), connector.center()[1] - float(symbol.getOriginalPoint().split(',')[1])]

                        origin = [0,0]

                        if 2 == len(symbol.getOriginalPoint().split(',')):

                            tokens = symbol.getOriginalPoint().split(',')

                            origin = [pt[0] + float(tokens[0]), pt[1] + float(tokens[1])]

                        end_break.buildItem(svgFileName, symbol.getType(), 5.7, pt, [end_break.boundingRect().width(), end_break.boundingRect().height()], origin, [], symbol.getBaseSymbol(), symbol.getAdditionalSymbol(), symbol.getHasInstrumentLabel())

                        end_break.set_property('Connected Item', connector.connectedItem)

                        end_break.setToolTip('owner : ' + str(line_end))

                        end_break.area = 'Drawing'

                        end_break.owner = line_end

                        end_breaks.append(end_break)

        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 end_breaks

    '''

        @Override (QEngineeringTextItem)

        @brief  get connected items

        @author Jeongwoo

        @date   2018.05.15

    '''

    def getConnectedItems(self):

        visited = []

        try:

            for run in self.runs:

                visited.extend(run.items)

        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 visited

    def explode(self, remainFromTo=False):

        """ explode line no """

        #if False == self.prop('Freeze'):

        try:

            for index in reversed(range(len(self.runs))):

                self.runs[index].explode()

        finally:

            self.runs.clear()

            if not remainFromTo:

                self.set_property('From', None)

                self.set_property('To', None)

    '''

        @brief      generate sql phrase to save to database(Notice: Line No's symbol is is 1)

        @author     humkyung

        @date       2018.08.14

    '''

    def toSql_return_separately(self):

        import uuid

        from EngineeringAbstractItem import QEngineeringAbstractItem

        res = []

        resLater = []

        app_doc_data = AppDocData.instance()

        cols = ['UID', 'Drawings_UID', 'Symbol_UID', 'X', 'Y', 'Width', 'Height', 'Rotation', 'Value', 'Connected', '[From]', '[To]']

        if type(self) is QEngineeringLineNoTextItem:

            values = ['?', '?', "(select UID from Symbol where Name='Line NO' and SymbolType_UID=-1)", '?', '?', '?', '?', '?', '?', '?', '?', '?']

        else:

            values = ['?', '?', "(select UID from Symbol where Name='Trim Line NO' and SymbolType_UID=-1)", '?', '?', '?', '?', '?', '?', '?', '?', '?']

        params = [(str(self.uid), str(app_doc_data.activeDrawing.UID), self.loc[0], self.loc[1], self.size[0], self.size[1], str(self.angle),\

        self.text(), str(self.conns[0]) if self.conns else None, str(self.prop('From')), str(self.prop('To')))]

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

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

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

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

        params = []

        attrs = self.getAttributes()

        for key,value in attrs.items():

            if key.Attribute == 'LINE NO':# or key.IsProp != 5:

                continue

            params.append((str(uuid.uuid4()), str(self.uid), str(key.UID), str(value)))

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

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

        # insert line no's Attributes

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

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

        params = []

        for key in attrs.keys():

            if key.IsProp != 5:

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

                               str(key.Freeze)))

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

        _index = 0

        for run in self.runs:

            resLater.extend(run.to_sql(_index, self))

            _index += 1

        return res, resLater

    '''

        @brief      return Line Data List

        @author     kyouho

        @date       2018.08.14

    '''

    def getLineDataList(self):

        dataList = []

        try:

            import uuid

            global lineColumnList

            docData = AppDocData.instance()

            attrs = self.getAttributes()

            for index in range(len(lineColumnList)):

                dataList.append('')

            dataList[20] = docData.imgName

            for key in attrs.keys():

                if type(key) is not UserInputAttribute:

                    lineProp = docData.getLinePropertiesByUID(key.UID)

                    if lineProp:

                        attrName = lineProp[0].Attribute.upper().replace(' ','')

                    else:

                        attrName = key.Attribute.upper().replace(' ','')

                    data = attrs[key]

                    if attrName == 'NOMINALDIAMETER':

                        dataList[1] = data

                    elif attrName == 'FLUIDCODE':

                        dataList[2] = data

                        dataList[7] = data

                    elif attrName == 'TAGSEQNO':

                        pass

                    elif attrName == 'INSULATIONPURPOSE':

                        dataList[16] = data

                    elif attrName == 'STREAMNO':

                        pass

                    elif attrName == 'LINENO' or attrName == 'LINE NO':

                        dataList[3] = data

                    elif attrName == 'PNIDNUMBER':

                        pass

                    elif attrName == 'PIPINGMATERIALSCLASS':

                        dataList[4] = data

                    elif attrName == '':

                        pass

                else:

                    typeUID = key.Attribute

                    value = key.text

                    lineAttr = docData.getLinePropertiesByUID(key.UD)

                    for index in range(len(lineColumnList)):

                        if lineColumnList[index] == lineAttr[0].Attribute:

                            dataList[index] = value

        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)

        if dataList[0] == '':

            dataList[0] = str(uuid.uuid4())

        return dataList

    def EvaluatedEQ(self):

        ''' evaluate line no's From / To equipment '''

        from EngineeringNozzleItem import QEngineeringNozzleItem

        from EngineeringVendorItem import QEngineeringVendorItem

        from EngineeringEquipmentItem import QEngineeringEquipmentItem

        if self.runs and self.runs[0]:

            items = self.runs[0].items

            if len(items) > 2:

                _attrs = self.getAttributes()

                if type(items[0]) is QEngineeringNozzleItem:

                    for connector in items[0].connectors:

                        # From

                        if (type(connector.connectedItem) is QEngineeringVendorItem or type(connector.connectedItem) is QEngineeringEquipmentItem) and \

                                connector.connectedItem not in items:

                            for _attr in _attrs:

                                if _attr.Attribute == 'From_eq' and self.add_assoc_item(connector.connectedItem, at=_attr.AttrAt):

                                    _attr.AssocItem = connector.connectedItem

                                    break

                            break

                if type(items[-1]) is QEngineeringNozzleItem:

                    for connector in items[0].connectors:

                        # To

                        if (type(connector.connectedItem) is QEngineeringVendorItem or type(connector.connectedItem) is QEngineeringEquipmentItem) and \

                                connector.connectedItem not in items:

                            for _attr in _attrs:

                                if _attr.Attribute == 'To_eq' and self.add_assoc_item(connector.connectedItem, at=_attr.AttrAt):

                                    _attr.AssocItem = connector.connectedItem

                                    break

                            break