HYTOS

# coding: utf-8

""" This is AppDatabase module """

import sqlite3

import pymssql

class AppDatabase:

    """ This is AppDatabase class """

    def __init__(self, type, host, user, password, db_path):

        self._DBType = type

        self._host = host

        self._user = user

        self._password = password

        self._db_path = db_path 

    @property

    def db_type(self):

        """ return database type """

        return self._DBType

    @db_type.setter

    def db_type(self, value):

        self._DBType = value

    @property

    def host(self):

        """ return host for mssql """

        return self._host

    @host.setter

    def host(self, value):

        self._host = value

    @property

    def user(self):

        """ return user for mssql """

        return self._user

    @user.setter

    def user(self, value):

        self._user = value

    @property

    def password(self):

        """ return password for mssql """

        return self._password

    @password.setter

    def password(self, value):

        self._password = value

    @property

    def db_name(self):

        """ return database name """

        return self._db_path

    @property

    def file_path(self):

        """ return sqlite database file path """

        return self._db_path

    @file_path.setter

    def file_path(self, value):

        self._db_path = value 

    @property

    def place_holder(self):

        """ return database placeholder """

        return '?' if self.db_type == 'SQLite' else '%s' if self.db_type == 'MSSQL' else None

    def connect(self):

        """ return database connection depends on database type """

        conn = None

        if self._DBType == 'SQLite':

            conn = sqlite3.connect(self.file_path, isolation_level=None)

            conn.row_factory = sqlite3.Row

            #cursor = conn.cursor()

        elif self._DBType == 'MSSQL':

            conn = pymssql.connect(host=self._host, user=self._user, password=self._password, database=self.db_name, charset='utf8', autocommit=False)

            #cursor = conn.cursor(as_dic=True)

        return conn

    def to_sql(self, sql):

        """ convert given sql string for database """

        return sql.replace('?', '%s') if self.db_type == "MSSQL" else sql

import os.path

import sys

import AbstractCommand

try:

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

    from PyQt5.QtWidgets import *

except ImportError:

    try:

        from PyQt4.QtCore import Qt, QPoint, QPointF, QRectF, pyqtSignal, QT_VERSION_STR, QMimeData

        from PyQt4.QtGui import QGraphicsView, QGraphicsScene, QImage, QPixmap, QPainterPath, QFileDialog, QColor, QPen, QBrush, QCursor

    except ImportError:

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

class HydroCalculationCommand(AbstractCommand.AbstractCommand):

    """ Hydro Calculation class """

    onSuccess = pyqtSignal(QGraphicsItem)

    def __init__(self, imageViewer):

        super(HydroCalculationCommand, self).__init__(imageViewer)

        self.name = 'HydroCalculation' 

        self.loops = []

    def execute(self, param):

        """ execute hydro calculation """

        from EngineeringOriginItem import QEngineeringOriginItem

        from EngineeringGuidelineItem import QEngineeringGuidelineItem

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringLoopItem import QEngineeringLoopItem

        queue = []

        try:

            pressurized = [item for item in self.imageViewer.scene.items() if type(item) is SymbolSvgItem and item.category == 'Equipment - [ Pressurized ]']

            for item in pressurized:

                matches = [conn for conn in item.connectors if conn.connectedItem and int(conn.connectedItem._conn_index) == 1]

                for match in matches:

                    queue.append(QEngineeringLoopItem([match]))

            while queue:

                loop = queue.pop()

                queue.extend(self.make_loop(loop))

        except Exception as ex:

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

            print('{}'.format(message))

    def make_loop(self, loop):

        """ make a loop """

        from EngineeringConnectorItem import QEngineeringConnectorItem

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringStreamlineItem import QEngineeringStreamlineItem

        from EngineeringLoopItem import QEngineeringLoopItem

        res = []

        try:

            while 1:

                if type(loop.items[-1]) is QEngineeringConnectorItem and type(loop.items[-1].parentItem()) is SymbolSvgItem:

                    if loop.items[-1].connectedItem and int(loop.items[-1].connectedItem._conn_index) == 1: # start at connector

                        loop.items.append(loop.items[-1].connectedItem.parentItem())    # it should be streamline

                        if type(loop.items[-1]) is QEngineeringStreamlineItem:

                            matches = [conn.connectedItem for conn in loop.items[-1].connectors if int(conn._conn_index) == 2 and conn.connectedItem]

                            if matches:

                                loop.items.append(matches[0])

                            else:

                                break 

                    elif loop.items[-1].connectedItem and int(loop.items[-1].connectedItem._conn_index) == 2:   # end at connector

                        matches = [conn for conn in loop.items[-1].parentItem().connectors if (not conn in loop.items) and conn.connectedItem and int(conn.connectedItem._conn_index) == 1]

                        if matches:

                            for match in matches[1:]:

                                res.append(QEngineeringLoopItem(loop.items + [match]))

                            loop.items.append(matches[0])

                        else:

                            break

        except Exception as ex:

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

            print('{}'.format(message)) 

        finally:

            self.loops.append(loop)

        return res

    def undo(self):

        pass

    def redo(self):

        pass

        """ execute hydro calculation """

        from HydroCalculationCommand  import HydroCalculationCommand

                            Calculation(hmb) 

                    """ generate loop """

                    cmd = HydroCalculationCommand(self.graphicsView)

                    cmd.execute(None)

                    self.load_HMB() 

        self._conn_index = index

    def __repr__(self):

        """ return string represent parent item and connector index """

        return '{}_N{}'.format(self.parentItem().name, self._conn_index)

        """ """

        """ setter of symbol_idx """

        """ getter of spec break """

# coding: utf-8

import os.path

import copy

import sys

try:

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

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

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

except ImportError:

    try:

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

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

    except ImportError:

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

from EngineeringAbstractItem import QEngineeringAbstractItem

from AppDocData import *

class QEngineeringLoopItem(QEngineeringAbstractItem):

    """ This is QEngineeringLoopItem class """

    def __init__(self, _items):

        """ constructure """

        import uuid

        QEngineeringAbstractItem.__init__(self)

        self._UID = None

        self._name = None

        self.items = _items

    def __repr__(self):

        """ return string represent loop item """

        return '{}'.format(self.items)

class Transfer(QObject):

    onRemoved = pyqtSignal(QGraphicsItem)

    def __init__(self, parent = None):

        QObject.__init__(self, parent)

            self._stream_no = QEngineeringStreamNoTextItem('0', self)

    def __repr__(self):

        """ return string represents stream line item """

        return 'Line_{}'.format(self._stream_no.toPlainText())