HYTOS

# coding: utf-8

""" This is document data(SDI) class """

import sys

import os

import sqlite3

import datetime

from enum import Enum

try:

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

    from PyQt5 import QtWidgets

except ImportError:

    from PyQt4.QtCore import *

    from PyQt4.QtGui import *

import numpy as np

from App import App

from SingletonInstance import SingletonInstane

import symbol

from NominalPipeSize import NominalPipeSize

class Source:

    def __init__(self, source):

        if type(source) is np.ndarray:

            self.source = Image.fromarray(source)

        elif type(source) is PngImagePlugin.PngImageFile or type(source) is JpegImagePlugin.JpegImageFile:

            self.source = source

        elif type(source) is QImage:

            self.source = Image.fromqimage(source)

        elif type(source) is QPixmap:

            self.source = Image.fromqpixmap(source)

    '''

        @history    2018.05.18  Jeongwoo    When Parameter [rect] is None, return whole image

    '''

    def getPyImageOnRect(self, rect=None):

        if rect is not None:

            return self.source.copy().crop((rect.left(), rect.top(), rect.right(), rect.bottom()))

        else:

            return self.source.copy()

    def getQImageOnRect(self, rect=None):

        image = ImageQt(self.getPyImageOnRect(rect))

        return image.convertToFormat(QImage.Format_RGBA8888)

class Config:

    def __init__(self, section, key, value):

        self.section = section

        self.key = key

        self.value = value

'''

    @brief      MessageType

    @author     humkyung 

    @date       2018.07.31

'''

class MessageType(Enum):

    Normal = 1

    Error = 2

    Information = 3

class AppDocData(SingletonInstane):

    def __init__(self):

        self._imgFilePath = None

        self.imgName = None

        self.imgWidth = 0

        self.imgHeight = 0

        self._OCRData = None

        self._areas = []

        self.equipments = []

        self.lineNos = []

        self.lines = []

        self.texts = []

        self.symbols = []

        self.unknowns = []

        self.tracerLineNos = []

        self.lineIndicators = []

        self._colors = None

        self._lineNoProperties = None

        self._lineTypes = None

        self._lineTypeConfigs = None

        self._activeDrawing = None

        self._titleBlockProperties = None

        self.needReOpening = None

        self.configTable = None

    def clearItemList(self, trim):

        '''

            @brief      clear item list

            @author     euisung

            @date       2018.11.28

        '''

        self.equipments.clear()

        self.symbols.clear()

        self.lineNos.clear()

        self.texts.clear()

        self.lines.clear()

        self.unknowns.clear()

        self.lineIndicators.clear()

        if trim:

            self.tracerLineNos.clear()

    '''

        @brief      clear

        @author     humkyung

        @date       2018.09.06

    '''

    def clear(self):

        self._imgFilePath = None

        self.imgName = None

        self.imgWidth = 0

        self.imgHeight = 0

        self._areas.clear()

        self.equipments.clear()

        self.lineNos.clear()

        self.lines.clear()

        self.texts.clear()

        self.symbols.clear()

        self.unknowns.clear()

        self.tracerLineNos.clear()

        self.lineIndicators.clear()

        self._colors = None

        self._lineNoProperties = None

        self._lineTypeConfigs = None

        self._activeDrawing = None

        self._titleBlockProperties = None

    '''

        @brief      Get DB file path in ProgramData

        @author     Jeongwoo

        @date       2018.06.27

        @history    2018.06.29  Jeongwoo    Change method to get template db path

    '''

    def getTemplateDbPath(self):

        path = os.path.join(os.getenv('ALLUSERSPROFILE'), App.NAME)

        templateDbPath = os.path.join(path, 'Template.db')

        return templateDbPath

    def getTemplateSymbolCategoryList(self):

        symbolCategoryList = []

        conn = sqlite3.connect(self.getTemplateDbPath())

        with conn:

            cursor = conn.cursor()

            sql = 'SELECT distinct category FROM SymbolType ORDER BY Category'

            try:

                cursor.execute(sql)

                rows = cursor.fetchall()

                for row in rows:

                    symbolCategoryList.append((row[0]))

            except Exception as ex:

                from App import App

                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 symbolCategoryList

    def getTemplateSymbolTypeList(self, category):

        symbolCategoryList = []

        conn = sqlite3.connect(self.getTemplateDbPath())

        with conn:

            cursor = conn.cursor()

            sql = 'SELECT UID, Type FROM SymbolType Where Category = ? ORDER BY Type'

            try:

                param = (category,)

                cursor.execute(sql, param)

                rows = cursor.fetchall()

                for row in rows:

                    symbolCategoryList.append((row[0], row[1]))

            except Exception as ex:

                from App import App

                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 symbolCategoryList

    def updateTemplateSymbol(self, uid, originalPoint, connectionPoint):

        isUpdated = False

        try:

            conn = sqlite3.connect(self.getTemplateDbPath())

            conn.execute('PRAGMA foreign_keys = ON')

            # Get a cursor object

            cursor = conn.cursor()

            sql = """Update Symbols

                        set OriginalPoint = ?

                          , ConnectionPoint = ?

                      where UID = ?"""

            param = (originalPoint, connectionPoint, uid)

            cursor.execute(sql, param)

            conn.commit()

            isUpdated = True

        # Catch the exception

        except Exception as ex:

            from App import App

            # Roll back any change if something goes wrong

            conn.rollback()

            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)

        finally:

            # Close the db connection

            conn.close()

            return isUpdated

    def getTemplateSymbol(self, UID):

        symbolList = []

        conn = sqlite3.connect(self.getTemplateDbPath())

        with conn:

            cursor = conn.cursor()

            sql = 'SELECT UID, Name, OriginalPoint, ConnectionPoint FROM Symbols Where UID = ? ORDER BY Name'

            try:

                param = (UID,)

                cursor.execute(sql, param)

                rows = cursor.fetchall()

                for row in rows:

                    symbolList.append((row[0], row[1], row[2], row[3]))

            except Exception as ex:

                from App import App

                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 symbolList

    def getTemplateSymbolNameList(self, typeUID):

        symbolCategoryList = []

        conn = sqlite3.connect(self.getTemplateDbPath())

        with conn:

            cursor = conn.cursor()

            sql = 'SELECT UID, Name FROM Symbols Where SymbolType_UID = ? ORDER BY Name'

            try:

                param = (typeUID,)

                cursor.execute(sql, param)

                rows = cursor.fetchall()

                for row in rows:

                    symbolCategoryList.append((row[0], row[1]))

            except Exception as ex:

                from App import App

                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 symbolCategoryList

    def getAppDbPath(self):

        """

        @brief      Get application DB file path in ProgramData

        @author     humkyung

        @date       2018.10.01

        """

        path = os.path.join(os.getenv('ALLUSERSPROFILE'), App.NAME)

        app_database = os.path.join(path, 'App.db')

        return app_database

    '''

        @brief  build application database

        @author humkyung

        @date   2018.04.20

    '''

    def buildAppDatabase(self):

        try:

            path = os.path.join(os.getenv('ALLUSERSPROFILE'), 'HYTOS')

            appDatabaseFilePath = os.path.join(path, 'App.db')

            # Creates or opens a file called mydb with a SQLite3 DB

            conn = sqlite3.connect(appDatabaseFilePath)

            conn.execute('PRAGMA foreign_keys = ON')

            with conn:

                # Get a cursor object

                cursor = conn.cursor()

                sqlFiles = ['App.sql']

                for sqlFile in sqlFiles:

                    filePath = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'Scripts', sqlFile)

                    try:

                        file = QFile(filePath)

                        file.open(QFile.ReadOnly)

                        sql = file.readAll()

                        sql = str(sql, encoding='utf8')

                        cursor.executescript(sql)

                    finally:

                        file.close()

                conn.commit()

        # Catch the exception

        except Exception as ex:

            from App import App

            # Roll back any change if something goes wrong

            conn.rollback()

            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)

    '''

        @brief  load app style

        @author humkyung

        @date   2018.04.20

    '''

    def loadAppStyle(self):

        style = 'Fusion'

        self.buildAppDatabase()

        return style

    @property

    def border_file_path(self):

        """ return border file path """

        path = os.path.join(os.getenv('ALLUSERSPROFILE'), App.NAME)

        return os.path.join(path, 'Border.png')

    @property

    def symbol_file_path(self):

        """ return svg symbol file path """

        path = os.path.join(os.getenv('ALLUSERSPROFILE'), App.NAME)

        return os.path.join(path, 'svg')

    def update_symbol_shape(self, drawing, symbol, svg_file):

        """update symbol shape"""

        conn = sqlite3.connect(drawing)

        conn.execute('PRAGMA foreign_keys = ON')

        with conn:

            try:

                conn.row_factory = sqlite3.Row

                # Get a cursor object

                cursor = conn.cursor()

                sql = f"update Symbols set Shape = ? where UID='{symbol}'"

                blob_data = None

                with open(svg_file, 'rb') as file:

                    blob_data = file.read()

                # Convert data into tuple format

                params = (blob_data,)

                cursor.execute(sql, params)

                conn.commit()

            # Catch the exception

            except Exception as ex:

                from App import App

                # Roll back any change if something goes wrong

                conn.rollback()

                message = 'error occurred({}) in {}:{}'.format(repr(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 read_symbol_shape(self, drawing, symbol):

        """read symbol shape"""

        res = None

        with sqlite3.connect(drawing) as conn:

            conn.execute('PRAGMA foreign_keys = ON')

            try:

                conn.row_factory = sqlite3.Row

                # Get a cursor object

                cursor = conn.cursor()

                sql = f"select Shape from Symbols where UID='{symbol}'"

                cursor.execute(sql)

                records = cursor.fetchall()

                for record in records:

                    res = record[0]

                    break

            # Catch the exception

            except Exception as ex:

                from App import App

                # Roll back any change if something goes wrong

                conn.rollback()

                message = 'error occurred({}) in {}:{}'.format(repr(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 res

    def getRoughness(self, phase_type):

        res = []

        conn = sqlite3.connect(self.activeDrawing.path)

        conn.execute('PRAGMA foreign_keys = ON')

        with conn:

            try:

                conn.row_factory = sqlite3.Row

                # Get a cursor object

                cursor = conn.cursor()

                sql = "select UID, Material, Meter, Inch, Feet, Milimeter from Roughness where phase_type = ?"

                param = (phase_type, )

                cursor.execute(sql, param)

                rows = cursor.fetchall()

                for row in rows:

                    res.append((row[0], row[1], row[2], row[3], row[4], row[5]))

            # Catch the exception

            except Exception as ex:

                from App import App

                # Roll back any change if something goes wrong

                conn.rollback()

                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 res

    def get_selected_nd(self, row_id, unit):

        res = None

        try:

            conn = sqlite3.connect(self.activeDrawing.path)

            conn.execute('PRAGMA foreign_keys = ON')

            # Get a cursor object

            cursor = conn.cursor()

            if unit == 'in':

                sql = 'select Inch from NominalDiameter where rowid <= ?'

            elif unit == 'mm':

                sql = 'select Milimeter from NominalDiameter where rowid <= ?'

            param = (row_id,)

            cursor.execute(sql, param)

            rows = cursor.fetchall()

            for row in rows:

                res = row[0]

        except Exception as ex:

            from App import App

            # Roll back any change if something goes wrong

            conn.rollback()

            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)

        finally:

            # Close the db connection

            conn.close()

        return res

    def get_row_id(self, size, unit):

        res = None

        try:

            conn = sqlite3.connect(self.activeDrawing.path)

            conn.execute('PRAGMA foreign_keys = ON')

            # Get a cursor object

            cursor = conn.cursor()

            if unit == 'in':

                sql = 'select count(*) from NominalDiameter where Inch <= ?'

            elif unit == 'mm':

                sql = 'select count(*) from NominalDiameter where Milimeter <= ?'

            param = (size,)

            cursor.execute(sql, param)

            rows = cursor.fetchall()

            for row in rows:

                res = row[0]

        except Exception as ex:

            from App import App

            # Roll back any change if something goes wrong

            conn.rollback()

            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)

        finally:

            # Close the db connection

            conn.close()

        return res

    def getInsideDiameter(self, nominaldiameter_uid, schedule_uid):

        res = []

        try:

            conn = sqlite3.connect(self.activeDrawing.path)

            conn.execute('PRAGMA foreign_keys = ON')

            # Get a cursor object

            cursor = conn.cursor()

            sql = """select UID

                          , Milimeter

                          , Inch 

                       from InsideDiameter

                      where NominalDiameter_UID = ?

                        and Schedule_UID = ?"""

            param = (nominaldiameter_uid, schedule_uid)

            cursor.execute(sql, param)

            rows = cursor.fetchall()

            for row in rows:

                res.append((row[0], row[1], row[2]))

        # Catch the exception

        except Exception as ex:

            from App import App

            # Roll back any change if something goes wrong

            conn.rollback()

            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)

        finally:

            # Close the db connection

            conn.close()

        return res

    def getSchedule(self):

        res = []

        conn = sqlite3.connect(self.activeDrawing.path)

        conn.execute('PRAGMA foreign_keys = ON')

        with conn:

            try:

                # Get a cursor object

                cursor = conn.cursor()

                sql = "select UID, No from Schedule"

                cursor.execute(sql)

                rows = cursor.fetchall()

                for row in rows:

                    res.append((row[0], row[1]))

            # Catch the exception

            except Exception as ex:

                from App import App

                # Roll back any change if something goes wrong

                conn.rollback()

                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 res

    def getNominalDiameterByUid(self, uid):

        res = []

        # Creates or opens a file called mydb with a SQLite3 DB

        conn = sqlite3.connect(self.activeDrawing.path)

        conn.execute('PRAGMA foreign_keys = ON')

        with conn:

            try:

                # Get a cursor object

                cursor = conn.cursor()

                sql = "select UID, Milimeter, Inch, Friction_Factor from NominalDiameter where uid = ?"

                param = (uid,)

                cursor.execute(sql, param)

                rows = cursor.fetchall()

                for row in rows:

                    res.append((row[0], row[1], row[2], row[3]))

            # Catch the exception

            except Exception as ex:

                from App import App

                # Roll back any change if something goes wrong

                conn.rollback()

                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 res

    def getNominalDiameter(self):

        res = []

        # Creates or opens a file called mydb with a SQLite3 DB

        conn = sqlite3.connect(self.activeDrawing.path)

        conn.execute('PRAGMA foreign_keys = ON')

        with conn:

            try:

                # Get a cursor object

                cursor = conn.cursor()

                sql = "select UID, Milimeter, Inch from NominalDiameter"

                cursor.execute(sql)

                rows = cursor.fetchall()

                for row in rows:

                    res.append((row[0], row[1], row[2]))

            # Catch the exception

            except Exception as ex:

                from App import App

                # Roll back any change if something goes wrong

                conn.rollback()

                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 res

    def getAppDrawing(self, uid):

        res = []

        try:

            # Creates or opens a file called mydb with a SQLite3 DB

            dbPath = self.getAppDbPath()

            conn = sqlite3.connect(dbPath)

            conn.execute('PRAGMA foreign_keys = ON')

            # Get a cursor object

            cursor = conn.cursor()

            sql = "select * from Drawings where uid=?"

            param = (uid,)

            cursor.execute(sql, param)

            rows = cursor.fetchall()

            for row in rows:

                res.append([row[0], row[1], row[2]])

        # Catch the exception

        except Exception as ex:

            from App import App

            # Roll back any change if something goes wrong

            conn.rollback()

            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)

        finally:

            # Close the db connection

            conn.close()

        return res

    def getAppConfigs(self, section, key=None):

        """

            @brief  get application configurations

            @author humkyung

            @date   2018.11.01

        """

        res = []

        try:

            # Creates or opens a file called mydb with a SQLite3 DB

            dbPath = self.getAppDbPath()

            with sqlite3.connect(dbPath) as conn:

                conn.execute('PRAGMA foreign_keys = ON')

                # Get a cursor object

                cursor = conn.cursor()

                if key is not None:

                    sql = "select * from configuration where section=? and key=?"

                    param = (section, key)

                else:

                    sql = "select * from configuration where section=?"

                    param = (section,)

                cursor.execute(sql, param)

                rows = cursor.fetchall()

                for row in rows:

                    res.append(Config(row[0], row[1], row[2]))

        # Catch the exception

        except Exception as ex:

            from App import App

            # Roll back any change if something goes wrong

            conn.rollback()

            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)

        finally:

            # Close the db connection

            conn.close()

        return res

    def getConfigs(self, section, key=None):

        """

            @brief  get application configurations

            @author humkyung

            @date   2018.11.01

        """

        res = []

        try:

            # Creates or opens a file called mydb with a SQLite3 DB

            conn = sqlite3.connect(self.activeDrawing.path)

            conn.execute('PRAGMA foreign_keys = ON')

            # Get a cursor object

            cursor = conn.cursor()

            if key is not None:

                sql = "select Section, Key, Value from configuration where section=? and key=?"

                param = (section, key)

            else:

                sql = "select Section, Key, Value from configuration where section=?"

                param = (section,)

            cursor.execute(sql, param)

            rows = cursor.fetchall()

            for row in rows:

                res.append(Config(row[0], row[1], row[2]))

        # Catch the exception

        except Exception as ex:

            from App import App

            # Roll back any change if something goes wrong

            conn.rollback()

            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)

        finally:

            # Close the db connection

            conn.close()

        return res

    def saveAppConfigs(self, configs):

        """

        @brief      save application configurations

        @author     humkyung

        @date       2018.10.01

        """

        try:

            # Creates or opens a file called mydb with a SQLite3 DB

            dbPath = self.getAppDbPath()

            with sqlite3.connect(dbPath) as conn:

                conn.execute('PRAGMA foreign_keys = ON')

                # Get a cursor object

                cursor = conn.cursor()

                for config in configs:

                    value = config.value

                    if type(value) is str and "'" in value:

                        value = value.replace("'", "''")

                    sql = "insert or replace into configuration values(?,?,?)"

                    param = (config.section, config.key, value)

                    cursor.execute(sql, param)

                conn.commit()

        # Catch the exception

        except Exception as ex:

            from App import App

            # Roll back any change if something goes wrong

            conn.rollback()

            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 update_roughness(self, roughness):

        try:

            # Creates or opens a file called mydb with a SQLite3 DB

            conn = sqlite3.connect(self.activeDrawing.path)

            conn.execute('PRAGMA foreign_keys = ON')

            # Get a cursor object

            cursor = conn.cursor()

            for r in roughness:

                uid = r[0]

                material = r[1]

                meter = r[2]

                inch = r[3]

                feet = r[4]

                millimeter = r[5]

                sql = """Update Roughness

                            Set Material = ?

                              , Meter = ?

                              , Inch = ?

                              , Feet = ?

                              , Milimeter = ? 

                          Where UID = ?"""

                param = (material, meter, inch, feet, millimeter, uid)

                cursor.execute(sql, param)

            conn.commit()

        except Exception as ex:

            from App import App

            # Roll back any change if something goes wrong

            conn.rollback()

            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)

        finally:

            # Close the db connection

            conn.close()

    def update_fittings(self, fittings):

        try:

            # Creates or opens a file called mydb with a SQLite3 DB

            with sqlite3.connect(self.activeDrawing.path) as conn:

                conn.execute('PRAGMA foreign_keys = ON')

                # Get a cursor object

                cursor = conn.cursor()

                for fitting in fittings:

                    uid = fitting[0]

                    k = fitting[1]

                    sql = """Update Fittings

                                Set K = ?

                              Where UID = ?"""

                    param = (k, uid)

                    cursor.execute(sql, param)

                sql = "insert or replace into SymbolType(UID,Category,Type) values(?,?,?)"

                param = ('8502d693-2e13-422f-b81a-67edf19dc07d', 'Callout', 'Callout')

                cursor.execute(sql, param)

                sql = "insert or replace into Symbols(UID,Name,Display_Name,SymbolType_UID,OriginalPoint) " \

                      "values(?,?,?,?,?)"

                param = ('c288afbb-2612-4b8e-9932-2a84815cfa4e', 'Callout', 'Callout',

                         '8502d693-2e13-422f-b81a-67edf19dc07d', '0,0,0,0')

                sql = "insert or replace into Symbols(UID,Name,Display_Name,SymbolType_UID,OriginalPoint) " \

                      "values(?,?,?,?,?)"

                param = ('22384e9d-74d7-4639-b500-73ac6285ff8a', 'Dimension', 'Dimension',

                         '8502d693-2e13-422f-b81a-67edf19dc07d', '0,0,0,0')

                cursor.execute(sql, param)

                conn.commit()

        except Exception as ex:

            from App import App

            # Roll back any change if something goes wrong

            conn.rollback()

            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 saveConfigs(self, configs):

        """

        @brief      save application configurations

        @author     humkyung

        @date       2018.10.01

        """

        try:

            # Creates or opens a file called mydb with a SQLite3 DB

            conn = sqlite3.connect(self.activeDrawing.path)

            conn.execute('PRAGMA foreign_keys = ON')

            # Get a cursor object

            cursor = conn.cursor()

            for config in configs:

                value = config.value

                if type(value) is str and "'" in value:

                    value = value.replace("'", "''")

                sql = "insert or replace into configuration values(?,?,?)"

                param = (config.section, config.key, value)

                cursor.execute(sql, param)

            conn.commit()

        # Catch the exception

        except Exception as ex:

            from App import App

            # Roll back any change if something goes wrong

            conn.rollback()

            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)

        finally:

            # Close the db connection

            conn.close()

    def initializeDataByDrawingUID(self, uid):

        try:

            # Creates or opens a file called mydb with a SQLite3 DB

            conn = sqlite3.connect(self.activeDrawing.path)

            conn.execute('PRAGMA foreign_keys = ON')

            # Get a cursor object

            cursor = conn.cursor()

            sql = "delete from Components"

            cursor.execute(sql)

            conn.commit()

        # Catch the exception

        except Exception as ex:

            from App import App

            # Roll back any change if something goes wrong

            conn.rollback()

            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)

        finally:

            # Close the db connection

            conn.close()

    def deleteDrawingByName(self, drawingName):

        """ delete given drawing """

        conn = sqlite3.connect(self.getAppDbPath())

        conn.execute('PRAGMA foreign_keys = ON')

        with conn:

            try:

                # Get a cursor object

                cursor = conn.cursor()

                sql = 'delete from Drawings where Name=?'

                param = (drawingName,)

                cursor.execute(sql, param)

                conn.commit()

            # Catch the exception

            except Exception as ex:

                from App import App

                # Roll back any change if something goes wrong

                conn.rollback()

                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 deleteAppConfigs(self, section, key=None):

        """

        @brief  delete application configurations

        @author humkyung

        @date   2018.11.01

        """

        try:

            # Creates or opens a file called mydb with a SQLite3 DB

            dbPath = self.getAppDbPath()

            conn = sqlite3.connect(dbPath)

            conn.execute('PRAGMA foreign_keys = ON')

            # Get a cursor object

            cursor = conn.cursor()

            if key is not None:

                sql = "delete from configuration where section='{}' and key='{}'".format(section, key)

            else:

                sql = "delete from configuration where section='{}'".format(section)

            cursor.execute(sql)

            conn.commit()

        # Catch the exception

        except Exception as ex:

            from App import App

            # Roll back any change if something goes wrong

            conn.rollback()

            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)

        finally:

            # Close the db connection

            conn.close()

    '''

        @brief  get symbol name

        @history    18.04.24    Jeongwoo    Add isExceptDetect Field

    '''

    def getSymbolByQuery(self, fieldName, param):

        ret = None

        conn = sqlite3.connect(self.activeDrawing.path)

        conn.execute('PRAGMA foreign_keys = ON')

        with conn:

            cursor = conn.cursor()

            sql = """select s.UID

                            , s.Name

                            , t.Category

                            , t.Type

                            , s.OriginalPoint

                            , s.ConnectionPoint

                        from Symbols s

                        inner join SymbolType t

                            on s.SymbolType_UID = t.UID 

                        where """ + "s." + fieldName + '=?'

            try:

                cursor.execute(sql, (param,))

                rows = cursor.fetchall()

                if rows is not None and len(rows) > 0:

                    symbolTuple = rows[0]

                    ret = symbol.SymbolBase(symbolTuple[0], symbolTuple[1], symbolTuple[2], symbolTuple[3],

                                            symbolTuple[4], symbolTuple[5])

            except Exception as ex:

                from App import App

                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 ret

    def getSymbolListByUID(self, uid):

        """ get symbol list by given uid """

        ret = []

        conn = sqlite3.connect(self.activeDrawing.path)

        conn.execute('PRAGMA foreign_keys = ON')

        with conn:

            cursor = conn.cursor()

            sql = """select s.UID

                            , s.Name

                            , t.Category

                            , t.Type

                            , s.OriginalPoint

                            , s.ConnectionPoint

                        from Symbols s

                        inner join SymbolType t

                            on s.SymbolType_UID = t.uid 

                        where s.SymbolType_UID = ?"""

            try:

                cursor.execute(sql, (uid,))

                rows = cursor.fetchall()

                if rows is not None and len(rows) > 0:

                    for row in rows:

                        sym = symbol.SymbolBase(row[0], row[1], row[2], row[3], row[4], row[5])

                        ret.append(sym)

            except Exception as ex:

                from App import App

                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 ret

    def get_mixed_pressure_variation(self, uid):

        res = []

        try:

            # Creates or opens a file called mydb with a SQLite3 DB

            dbPath = os.path.join(self.activeDrawing.path)

            conn = sqlite3.connect(dbPath)

            conn.execute('PRAGMA foreign_keys = ON')

            conn.row_factory = sqlite3.Row

            # Get a cursor object

            cursor = conn.cursor()

            sql = """select Element

                          , Inside_Pipe_Size

                          , Length

                          , Angle

                          , K

                          , Pressure

                          , Void

                          , Quality

                          , Density

                          , V_Den

                          , Mean_Vel

                          , Max_Vel

                          , Ero_Vel

                          , Pattern_X

                          , Pattern_Y

                          , Regime

                          , Friction

                          , Gravity

                          , Momentum

                          , Total

                       from PressureVariation

                      where Components_UID = ?

                      order by rowid"""

            param = (uid,)

            cursor.execute(sql, param)

            rows = cursor.fetchall()

            for row in rows:

                res.append((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9],

                            row[10], row[11], row[12], row[13], row[14], row[15], row[16], row[17], row[18], row[19]))

        # Catch the exception

        except Exception as ex:

            from App import App

            # Roll back any change if something goes wrong

            conn.rollback()

            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)

        finally:

            # Close the db connection

            conn.close()

        return res

    def get_geometry_input(self, uid):

        res = []

        try:

            # Creates or opens a file called mydb with a SQLite3 DB

            dbPath = os.path.join(self.activeDrawing.path)

            conn = sqlite3.connect(dbPath)

            conn.execute('PRAGMA foreign_keys = ON')

            conn.row_factory = sqlite3.Row

            # Get a cursor object

            cursor = conn.cursor()

            sql = """select Element

                          , Nominal_Pipe_Size

                          , Schedule_No

                          , Inside_Pipe_Size

                          , Roughness

                          , Length

                          , Angle

                          , RPD

                          , D1_D2

                          , K

                       from Geometry_Input

                      where Components_UID = ?

                      order by rowid"""

            param = (uid,)

            cursor.execute(sql, param)

            rows = cursor.fetchall()

            for row in rows:

                res.append((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9]))

        # Catch the exception

        except Exception as ex:

            from App import App

            # Roll back any change if something goes wrong

            conn.rollback()

            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)

        finally:

            # Close the db connection

            conn.close()

        return res

    def get_fittings_input(self, uid):

        res = []

        try: