HYTOS

# coding: utf-8

""" This is engineering abstract item module """

import sys

'''

    @history    2018.05.15  Jeongwoo    Remove Parent Object [QObject]

'''

class QEngineeringAbstractItem:

    '''

        @history    2018.05.15  Jeongwoo    Remove call super

                    2018.05.17  Jeongwoo    Add DEFAULT_COLOR Variable

    '''

    DEFAULT_COLOR = '#0000FF'

    HOVER_COLOR   = '#BC4438'

    CONNECTED_AT_PT = 0

    CONNECTED_AT_BODY = 1

    HOVER_ZVALUE = 200

    def __init__(self, parent=None):

        self._color = self.DEFAULT_COLOR # default color

        self._owner = None

        self.conns = []

        self.special_item_type = None   # UID for special item type

        self._hover = False

        self._area = None

        self.connectors = []

        self.attrs = {} # attributes

        self._associations = {'Text Item':[], 'Symbol Item':[]} # associated items

    @property

    def hover(self):

        """ return hover """

        return self._hover

    @hover.setter

    def hover(self, value):

        """ set hover """

        self._hover = value

    def change_color(self, value):

        """ change item's color """

        self._color = value

    def highlight(self, flag):

        pass

    '''

        @brief      Abstract method. Variable [color] is RGB hex code

        @author     Jeongwoo

        @date       2018.05.11

    '''

    def setColor(self, color):

        raise NotImplementedError

    '''

        @brief  return color

        @author Jeongwoo

        @date   2018.05.11

    '''

    def getColor(self):

        return QEngineeringAbstractItem.HOVER_COLOR if self.hover else (self.owner.getColor() if (self.owner and hasattr(self.owner, '_color')) else self._color)

    '''

        @brief  getter of owner

        @author humkyung

        @date   2018.05.12

    '''

    @property

    def owner(self):

        return self._owner 

    '''

        @brief  setter of owner

        @author humkyung

        @date   2018.05.12

    '''

    @owner.setter

    def owner(self, value):

        self._owner = value

    @property

    def has_connection(self):

        """ check this is connected to other """

        for connector in self.connectors:

            if connector.connectedItem: return True

        return False

    def validate(self):

        """ validate this """

        raise NotImplementedError('To be implemented')

    '''

        @brief  getter of area

        @author humkyung

        @date   2018.09.06

    '''

    @property

    def area(self):

        return self._area if self._area is not None else 'None'

    '''

        @brief  setter of area

        @author humkyung

        @date   2018.09.06

    '''

    @area.setter

    def area(self, value):

        self._area = value

    '''

        @brief  write to xml

        @author humkyung

        @date   2018.05.16

    '''

    def toXml(self):

        pass

    '''

        @brief  write attribute to xml

        @author humkyung

        @date   2018.05.16

    '''

    def toXmlAsAttribute(self, parent):

        pass

    def toSql(self):

        """convert to sql query"""

        pass

    def isOverlap(self, rect1, rect2):

        """

        @brief  return true if rects have intersection, rect is QRect

        @author euisung

        @date   2019.09.02

        """

        lt1, rb1 = (rect1.left(), rect1.top()), (rect1.right(), rect1.bottom())

        lt2, tb2 = (rect2.left(), rect2.top()), (rect2.right(), rect2.bottom())

        if rect1.left() > rect2.right() or rect2.left() > rect1.right():

            return False

        if rect1.bottom() < rect2.top() or rect2.bottom() < rect1.top():

            return False

        return True

    def associations(self):

        """ return associated instance """

        # move to abstractitem

        import uuid

        res = []

        for key in self._associations.keys():

            index = 0

            for assoc in list(set(self._associations[key])):

                # find owner with uid if self.scene() is valid

                if self.scene() and assoc and type(assoc) is uuid.UUID:

                    matches = [x for x in self.scene().items() if hasattr(x, 'uid') and str(x.uid) == str(assoc)]

                    if matches:

                        res.append(matches[0])

                        self._associations[key][index] = matches[0]

                # up to here

                elif assoc:

                    res.append(assoc)

                index += 1

        for key in self.attrs.keys():

            if type(key.AssocItem) is uuid.UUID:

                for assoc in res:

                    if str(key.AssocItem) == str(assoc.uid):

                        key.AssocItem = assoc

        return res

    def get_assoc_item(self, assoc):

        """ get associated item of given object """

        import uuid

        if assoc and type(assoc) is uuid.UUID:

            matches = [x for x in self.scene().items() if hasattr(x, 'uid') and str(x.uid) == str(assoc)]

            if matches: return matches[0]

        return assoc

    def texts(self):

        """ return text type of associations """

        from EngineeringTextItem import QEngineeringTextItem

        res = []

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

            consumed = False

            for key in list(self.attrs.keys()):

                if key.AssocItem and key.AssocItem is text:

                    consumed = True

            if not consumed:

                res.append(text)

        return res

    def symbols(self):

        """ return symbol type of associations """

        from SymbolSvgItem import SymbolSvgItem

        res = []

        for symbol in [x for x in self.associations() if issubclass(type(x), SymbolSvgItem)]:

            consumed = False

            for key in list(self.attrs.keys()):

                if key.AssocItem and key.AssocItem is symbol:

                    consumed = True

            if not consumed:

                res.append(symbol)

        return res

    def getAttributes(self):

        _attrs = {}

        try:

            from AppDocData import AppDocData

            from SymbolSvgItem import SymbolSvgItem

            from EngineeringTextItem import QEngineeringTextItem

            from EngineeringValveOperCodeTextItem import QEngineeringValveOperCodeTextItem

            from EngineeringLineItem import QEngineeringLineItem

            from EngineeringVendorItem import QEngineeringVendorItem

            """ get attributes of item from database """

            docData = AppDocData.instance()

            if type(self) is QEngineeringLineItem:

                symbolAttrs =  docData.getSymbolAttribute('Line')

            elif type(self) is QEngineeringVendorItem:

                symbolAttrs =  docData.getSymbolAttribute('Package')

            else:

                symbolAttrs = docData.getSymbolAttribute(self.type)

            targetAttrs = []

            if type(self) is not QEngineeringLineItem:

                for attr in symbolAttrs:

                    if attr.Target is None or attr.Target == 'ALL' or [target for target in attr.Target.split(',') if self.dbUid is int(target)]:

                        targetAttrs.append(attr)

            else:

                targetAttrs = symbolAttrs

            _texts = self.texts()

            _symbols = self.symbols()

            for attr in targetAttrs:

                matches = [_attr for _attr,_ in self.attrs.items() if _attr.UID == attr.UID]

                if matches:

                    attr.Freeze = matches[0].Freeze         # update freeze value

                    attr.AssocItem = matches[0].AssocItem

                    _attrs[attr] = self.attrs[matches[0]]   # copy attribute value

                else:

                    _attrs[attr] = ''

                # if attr.Freeze: continue    # do not evaluate value if attribute is frozen

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

                    at = int(attr.AttrAt)

                    # Text Item can contain Valve Oper Code

                    if attr.AttributeType == 'Text Item':

                        items = _texts

                    else:

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

                    if not attr.AssocItem and len(items) > at and not attr.Codes.values:

                        attr.AssocItem = items[at]

                        item = attr.AssocItem

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

                    elif attr.AssocItem:

                        item = attr.AssocItem = self.get_assoc_item(attr.AssocItem)

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

                    else:

                        _attrs[attr] = ''

                elif attr.AttributeType == 'Size Text Item':

                    at = int(attr.AttrAt)

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

                    if not attr.AssocItem and len(items) > at:

                        attr.AssocItem = items[at]

                        item = attr.AssocItem

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

                    else:

                        item = attr.AssocItem = self.get_assoc_item(attr.AssocItem)

                        _attrs[attr] = eval(attr.Expression) if attr.Expression and ((item and 'item' in attr.Expression) or 'self' in attr.Expression) else ''

                elif attr.AttributeType == 'Symbol Item' or attr.AttributeType == 'Line Item' or attr.AttributeType == 'Comp Item':

                    at = int(attr.AttrAt)

                    if not attr.AssocItem and len(_symbols) > at:

                        attr.AssocItem = _symbols[at]

                        item = attr.AssocItem

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

                    elif attr.AssocItem:

                        item = attr.AssocItem = self.get_assoc_item(attr.AssocItem)

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

                    else:

                        _attrs[attr] = ''

                elif attr.AttributeType == 'Tag No':

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

                elif attr.AttributeType == 'String':

                    _attrs[attr] = attr.Expression if attr.Expression and not _attrs[attr] else _attrs[attr]

            for _attr,_value in _attrs.items():

                if _value is None or _value == '':

                    _attr.AssocItem = None

            self.attrs = _attrs

        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 self.attrs

    def attrib(self, name):

        """ return the value of given attribute with name """

        matches = [(attr,value) for attr,value in self.getAttributes().items() if attr.Attribute == name]

        if matches: return matches[0][1]

        return None

    def set_attrib(self, attrib, value):

        """ set attribute with given value """

        matches = [attr for attr,_ in self.attrs.items() if attr.UID == attrib.UID]

        if len(matches) == 1: self.attrs[matches[0]] = value

    @staticmethod

    def assoc_type(item):

        """ return association type of given item """

        from EngineeringTextItem import QEngineeringTextItem

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringValveOperCodeTextItem import QEngineeringValveOperCodeTextItem

        from QEngineeringSizeTextItem import QEngineeringSizeTextItem

        from QEngineeringTagNoTextItem import QEngineeringTagNoTextItem

        from EngineeringLineItem import QEngineeringLineItem

        _type = None

        if type(item) is QEngineeringSizeTextItem:

            _type = 'Size Text Item'

        elif type(item) is QEngineeringValveOperCodeTextItem:

            _type = 'Valve Oper Code'

        elif type(item) is QEngineeringTagNoTextItem:

            _type = 'Tag No'

        elif type(item) is QEngineeringTextItem or issubclass(type(item), QEngineeringTextItem):

            _type = 'Text Item'

        elif type(item) is SymbolSvgItem or issubclass(type(item), SymbolSvgItem):

            _type = 'Symbol Item'

        elif type(item) is QEngineeringLineItem:

            _type = 'Line Item'

        elif issubclass(type(item), SymbolSvgItem) or type(item) is QEngineeringLineItem:

            _type = 'Comp Item'

        return _type

    def clear_attr_and_assoc_item(self, force=False):

        """ clear attrs, return true if clear attrs """

        if force:

            self.attrs.clear()

            self._associations.clear()

            return True

        else:

            freeze = False

            for key in self.attrs.keys():

                if key.Freeze:

                    freeze = True

                    break

            if freeze:

                return False

            else:

                self.attrs.clear()

                self._associations.clear()

                return True

    def add_assoc_item(self, item, at=None, force=False):

        """ add given item to association """

        from EngineeringTextItem import QEngineeringTextItem

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringValveOperCodeTextItem import QEngineeringValveOperCodeTextItem

        from QEngineeringSizeTextItem import QEngineeringSizeTextItem

        if not force:

            for key in self.attrs.keys():

                if key.Freeze:

                    return False

        _type = QEngineeringAbstractItem.assoc_type(item)

        if _type is not None:

            if not _type in self._associations:

                self._associations[_type] = []

            if item in self._associations[_type]: return True

            if at is None:

                self._associations[_type].append(item)

            else:

                while len(self._associations[_type]) <= at: self._associations[_type].append(None)

                #if len(self._associations[_type]) > at and self._associations[_type][at] is not None:

                #    self._associations[_type][at].owner = None

                self._associations[_type][at] = item

            return True

        return False

    def remove_assoc_item(self, item):

        """ remove given item from association """

        _type = QEngineeringAbstractItem.assoc_type(item)

        if _type is not None:

            if _type in self._associations and item in self._associations[_type]:

                index = self._associations[_type].index(item)

                self._associations[_type].pop(index)