HYTOS

# coding: utf-8

""" This is engineering run item moduel """

import sys

import os.path

import copy

try:

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

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

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

except ImportError:

    try:

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

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

    except ImportError:

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

from EngineeringAbstractItem import QEngineeringAbstractItem

class QEngineeringRunItem(QEngineeringAbstractItem):

    """ This is engineering run item class """

    def __init__(self):

        import uuid

        QEngineeringAbstractItem.__init__(self)

        self.uid = uuid.uuid4() # generate UUID

        self._items = []

        self._visible = False

        self.owner = None

    @property

    def Type(self):

        """ return type of run(Drain/Process) """

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringLineItem import QEngineeringLineItem

        if len(self._items) == 2:

            if 1 == len([item for item in self._items if type(item) is QEngineeringLineItem]) and\

            1 == len([item for item in self._items if type(item) is SymbolSvgItem]): return 'Drain'

        return 'Process'

    @property

    def visible(self):

        """ return visible """

        return self._visible

    @visible.setter

    def visible(self, value):

        """ set visible value """

        self._visible = value

        for item in self.items:

            if issubclass(type(item), QGraphicsItem):

                item.setVisible(value)

    '''

        @brief  getter of items

        @author humkyung

        @date   2018.05.15

    '''

    @property

    def items(self):

        return self._items

    '''

        @brief  setter of items

        @author humkyung

        @date   2018.05.15

    '''

    @items.setter

    def items(self, value):

        self._items = value

    def explode(self):

        """ explode run and subtract it from line no """

        try:

            for item in self.items:

                item.owner = None

        finally:

            self.items.clear()

            if self.owner: self.owner.runs.remove(self)

    '''

        @brief  get two points which's length is max

        @author humkyung

        @date   2018.05.23

    '''

    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

    def arrange_flow_direction(self):

        """ arrange flow direction of line """

        from EngineeringLineItem import QEngineeringLineItem

        for at in range(len(self.items)):

            if type(self.items[at]) is QEngineeringLineItem and at > 0:

                self.items[at].arrange_flow_direction(self.items[at-1])

            elif type(self.items[at]) is QEngineeringLineItem and len(self.items) > 1:

                self.items[at].arrange_flow_direction(self.items[at+1])

                self.items[at].reverse()

    def reverse(self):

        """ reverse line's flow direction """

        from EngineeringLineItem import QEngineeringLineItem

        self.items.reverse()

        for at in range(len(self.items)):

            if type(self.items[at]) is QEngineeringLineItem:

                self.items[at].reverse()

    '''

        @brief  add flow mark

        @author humkyung

        @date   2018.06.17

    '''

    def addFlowMark(self):

        from EngineeringLineItem import QEngineeringLineItem

        try:

            connectedLines = [item for item in self.items if type(item) is QEngineeringLineItem]

            maxLength = None

            maxLengthItem = None

            for line in connectedLines:

                length = line.length()

                if maxLength is None or maxLength < length:

                    maxLength = length

                    maxLengthItem = line

            if maxLengthItem is not None: maxLengthItem.addFlowArrow()

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

    '''

        @brief  write to xml

        @author humkyung

        @date   2018.05.16

        @history    Jeongwoo 2018.05.24 Add math.fabs() on sublist's if-statement

                                        Change toler(1 → 5) and Modify Longest Line's coords // Make comments Test Code

                    humkyung 2018.06.22 sort lines before writing to xml

                    kyouho  2018.08.09 Line 묶기

    '''

    def toXml(self):

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

        from EngineeringLineItem import QEngineeringLineItem

        from SymbolSvgItem import SymbolSvgItem

        try:

            node = Element('RUN')

            node.attrib['TYPE'] = self.Type

            for item in self.items:

                # skip line item which's connected items are same

                if (type(item) is QEngineeringLineItem) and item.connectors[0].connectedItem is not None and (item.connectors[0].connectedItem is item.connectors[1].connectedItem):

                    continue

                # up to here

                xml = item.toXml()

                if xml is not None:

                    node.append(item.toXml())

        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 to_sql(self, index, owner):

        """ generate sql phrase to save run to database """

        import uuid

        from AppDocData import AppDocData

        res = []

        app_doc_data = AppDocData.instance()

        cols = ['UID', 'Drawings_UID', '[Type]', 'Owner', '[Index]']

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

        params = [(str(self.uid), str(app_doc_data.activeDrawing.UID), self.Type, str(owner), index)]

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

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

        cols = ['UID', 'PipeRuns_UID', '[Index]', 'Components_UID']

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

        params = []

        _index = 1

        for item in self.items:

            params.append((str(uuid.uuid4()), str(self.uid), _index, str(item.uid)))

            _index += 1

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

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

        return res