/HYTOS/HYTOS/AppDocData.py - HYTOS - 일정관리

hytos / HYTOS / HYTOS / AppDocData.py @ 2ab99cff

       # 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  return size value string
               @author humkyung
               @date   2018.04.24
           '''
           def sizeValue(self):
               return self.inchStr if 'Inch' == self.sizeUnit else self.metricStr
       '''
           @brief  Pipe color class
       '''
       class Color:
           def __init__(self, index, red, green, blue):
               self.index = index
               self.red = red
               self.green = green
               self.blue = blue
       '''
           @brief      MessageType
           @author     humkyung
           @date       2018.07.31
       '''
       class MessageType(Enum):
           Normal = 1
           Error = 2
       class AppDocData(SingletonInstane):
           DATABASE = App.NAME + '.db'
           def __init__(self):
               from DisplayColors import DisplayColors
               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 drawing file list
               @author     euisung
               @date       2018.09.28
           '''
           def getDrawingFileList(self):
               """
               get drawing files which's extension is .png or jpg from drawing folder
               """
               try:
                   project = AppDocData.instance().getCurrentProject()
                   path = project.getDrawingFilePath()
                   drawingFileList = [f for f in os.listdir(path) if os.path.isfile(os.path.join(path, f)) and (os.path.splitext(f)[1] == '.png' or os.path.splitext(f)[1] == '.jpg' or os.path.splitext(f)[1] == '.jpeg' or os.path.splitext(f)[1] == '.JPEG' or os.path.splitext(f)[1] == '.PNG')]
                   drawingFileList.sort()
               except Exception as ex:
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               return drawingFileList
           '''
               @brief      Get Training file list
               @author     euisung
               @date       2018.10.16
           '''
           def getTrainingFileList(self):
               try:
                   project = AppDocData.instance().getCurrentProject()
                   path = project.getTrainingFilePath()
                   drawingFileList = os.listdir(path)
                   drawingFileList.sort()
               except Exception as ex:
                   from App import App
                   message = 'error occured({}) 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 drawingFileList
           '''
               @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 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  getter of colors
               @author humkyung
               @date   2018.06.18
           '''
           @property
           def colors(self):
               import random
               if self._colors is None or self._colors == []:
                   self._colors = []
                   try:
                       dbPath = os.path.join(self.getCurrentProject().getDbFilePath() , AppDocData.DATABASE)
                       conn = sqlite3.connect(dbPath)
                       cursor = conn.cursor()
                       sql = 'SELECT UID,RED,GREEN,BLUE FROM Colors'
                       cursor.execute(sql)
                       rows = cursor.fetchall()
                       for row in rows:
                           self._colors.append(Color(int(row[0]), int(row[1]), int(row[2]), int(row[3])))
                   # Catch the exception
                   except Exception as ex:
                       # Roll back any change if something goes wrong
                       conn.rollback()
                       from App import App
                       message = 'error occured({}) 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:
                       conn.close()
               return self._colors.pop(random.randrange(0, len(self._colors)))
           '''
               @brief  setter of colors
               @author humkyung
               @date   2018.06.18
           '''
           @colors.setter
           def colors(self, value):
               self._colors = value
           '''
               @brief      set image file path
               @author     humkyung
               @date       2018.07.30
           '''
           def setImgFilePath(self, path):
               self._imgFilePath = path
               self.imgName = os.path.splitext(os.path.basename(self._imgFilePath))[0]
           '''
               @brief  getter of line type configs
               @author humkyung
               @date   2018.06.28
           '''
           @property
           def lineTypeConfigs(self):
               from PyQt5.QtCore import Qt
               if self._lineTypeConfigs is None:
                   self._lineTypeConfigs = []
                   styleMap = [('SolidLine', Qt.SolidLine), ('DashLine', Qt.DashLine), ('DotLine', Qt.DotLine), ('DashDotLine', Qt.DashDotLine),
                       ('DashDotDotLine', Qt.DashDotDotLine), ('CustomDashLine', Qt.CustomDashLine)]
                   configs = self.getConfigs('LineTypes')
                   for config in configs:
                       color, width, _style, transparent = config.value.split(',')
                       matches = [param for param in styleMap if param[0] == _style]
                       style = matches[0][1] if matches else Qt.SolidLine
                       self._lineTypeConfigs.append((config.key, color, int(width), style, float(transparent)))
               return self._lineTypeConfigs
           '''
               @brief  setter of line type configs
               @author humkyung
               @date   2018.06.28
           '''
           @lineTypeConfigs.setter
           def lineTypeConfigs(self, value):
               self._lineTypeConfigs = value
           @property
           def drain_size(self):
               """ getter of drain_size """
               if not hasattr(self, '_drain_size') or not self._drain_size:
                   configs = self.getConfigs('Drain Size Rule', 'Size')
                   self._drain_size = configs[0].value if configs else '1"'
               return self._drain_size
           @drain_size.setter
           def drain_size(self, value):
               """ setter of drain_size """
               self._drain_size = value
           '''
               @brief  get line type config of given line type
               @author humkyung
               @date   2018.06.28
           '''
           def getLineTypeConfig(self, lineType):
               from PyQt5.QtCore import Qt
               matches = [config for config in self.lineTypeConfigs if config[0] == lineType]
               return matches[0] if matches else (lineType, '#0000FF', 5, Qt.SolidLine, 50)
           def setCurrentPidSource(self, image):
               self.imgWidth, self.imgHeight = image.size
               self.currentPidSource = Source(image)
           def getCurrentPidSource(self):
               return self.currentPidSource
           '''
               @brief      Check if data exists or not
               @author     Jeongwoo
               @date       2018.05.03
           '''
           def isExistData(self, fieldName, data):
               rows = None
               try:
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   cursor = conn.cursor()
                   sql = ""
                   if isinstance(data, str):
                       sql = "SELECT * FROM Symbol WHERE " + fieldName + " = '"+ data +"'"
                   else:
                       sql = "SELECT * FROM Symbol WHERE " + fieldName + " = "+ str(data) +""
                   cursor.execute(sql)
                   rows = cursor.fetchall()
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   conn.close()
                   if rows is not None and len(rows) > 0:
                       return True
                   else:
                       return False
           '''
               @brief      Check if exist file name or not
               @author     Jeongwoo
               @date       2018.05.03
           '''
           def isExistFileName(self, name):
               rows = None
               try:
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   cursor = conn.cursor()
                   sql = "SELECT * FROM Symbol WHERE name = '"+ name +"'"
                   cursor.execute(sql)
                   rows = cursor.fetchall()
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   conn.close()
                   if rows is not None and len(rows) > 0:
                       return True
                   else:
                       return False
           '''
               @brief      Insert new symbol into Symbol Table, Moved from SG_DbHelper
               @author     Jeongwoo
               @date       2018.05.03
           '''
           def insertSymbol(self, symbol):
               isAdded = False
               try:
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   INSERT_SYMBOL_SQL = """
                       INSERT INTO Symbol(name, SymbolType_UID, threshold, minMatchPoint, isDetectOrigin, rotationCount, ocrOption, isContainChild, originalPoint, connectionPoint, baseSymbol, additionalSymbol, isExceptDetect, hasInstrumentLabel, width, height, flip)
                       VALUES(?, (select UID from SymbolType where Type=?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);
                   """
                   cursor = conn.cursor()
                   query = ( symbol.getName(), symbol.getType(), symbol.getThreshold()
                                  , symbol.getMinMatchCount(), symbol.getIsDetectOnOrigin(), symbol.getRotationCount()
                                  , symbol.getOcrOption(), symbol.getIsContainChild()
                                  , symbol.getOriginalPoint(), symbol.getConnectionPoint()
                                  , symbol.getBaseSymbol(), symbol.getAdditionalSymbol(), symbol.getIsExceptDetect(), symbol.getHasInstrumentLabel()
                                  , symbol.width, symbol.height, symbol.detectFlip)
                   cursor.execute(INSERT_SYMBOL_SQL, query)
                   conn.commit()
                   isAdded = True
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   conn.close()
                   return (isAdded, symbol.getType(), symbol.getName(), symbol.getPath())
           '''
               @brief      Update symbol in Symbol Table, Moved from SG_DbHelper
               @author     Jeongwoo
               @date       2018.05.03
           '''
           def updateSymbol(self, symbol):
               isUpdated = False
               try:
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   UPDATE_SYMBOL_SQL = """
                       UPDATE Symbols
                          SET name = ?
                            , originalPoint = ?
                            , connectionPoint = ?
                        WHERE uid = ?
                   """
                   cursor = conn.cursor()
                   query = (symbol.getName(), symbol.getOriginalPoint(), symbol.getConnectionPoint(), symbol.getUid())
                   cursor.execute(UPDATE_SYMBOL_SQL, query)
                   conn.commit()
                   isUpdated = True
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   conn.close()
                   return (isUpdated, symbol.getType(), symbol.getName(), symbol.getPath())
           '''
               @brief      Get Detecting Target Symbol List (Field 'isExceptDetect' == False(0))
               @author     Jeongwoo
               @date       18.04.24
               @history    humkyung 2018.06.28 select symbol order by threshold descending
           '''
           def getTargetSymbolList(self):
               targetSymbolList = []
               try:
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   cursor = conn.cursor()
                   #sql = """SELECT a.UID,a.Name,b.Type,a.Threshold,a.MinMatchPoint,a.IsDetectOrigin,a.RotationCount,a.OCROption,a.IsContainChild,a.OriginalPoint,a.ConnectionPoint,
                   #        a.BaseSymbol,a.AdditionalSymbol,a.IsExceptDetect,a.HasInstrumentLabel,a.flip FROM Symbol a inner join SymbolType b on a.SymbolType_UID=b.UID WHERE a.IsExceptDetect = 0 order by width * height desc"""
                   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"""
                   try:
                       cursor.execute(sql)
                       rows = cursor.fetchall()
                       for row in rows:
                           sym = symbol.SymbolBase(row[0], row[1], row[2], row[3], row[4], row[5])
                           targetSymbolList.append(sym)
                   except Exception as ex:
                       print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   conn.close()
               return targetSymbolList
           '''
               @brief  build application database
               @author humkyung
               @date   2018.04.20
           '''
           def buildAppDatabase(self):
               try:
                   path = os.path.join(os.getenv('ALLUSERSPROFILE'), App.NAME)
                   appDatabaseFilePath = os.path.join(path, 'App.db')
                   # Creates or opens a file called mydb with a SQLite3 DB
                   conn = sqlite3.connect(appDatabaseFilePath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sqlFiles = ['App.Configuration.sql', 'App.Styles.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:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
               configs = [Config('app', 'mode', 'advanced'), Config('app', 'error origin point', '51,72')]
               self.saveAppConfigs(configs)
           '''
               @brief  load app style
               @author humkyung
               @date   2018.04.20
           '''
           def loadAppStyle(self):
               style = 'Fusion'
               path = os.path.join(os.getenv('ALLUSERSPROFILE'), App.NAME)
               if not os.path.exists(path): os.makedirs(path)
               self.buildAppDatabase()
               try:
                   appDatabaseFilePath = os.path.join(path, 'App.db')
                   # Creates or opens a file called mydb with a SQLite3 DB
                   conn = sqlite3.connect(appDatabaseFilePath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = "select Value from Configuration where Section='App' and Key='Style'"
                   cursor.execute(sql)
                   rows = cursor.fetchall()
                   style = rows[0][0] if 1 == len(rows) else 'Fusion'
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
               return style
           '''
               @brief  load app styles and then return a list
               @author humkyung
               @date   2018.04.20
           '''
           def loadAppStyles(self):
               styles = []
               try:
                   self.buildAppDatabase()
                   path = os.path.join(os.getenv('ALLUSERSPROFILE'), App.NAME)
                   appDatabaseFilePath = os.path.join(path, 'App.db')
                   # Creates or opens a file called mydb with a SQLite3 DB
                   conn = sqlite3.connect(appDatabaseFilePath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = 'select UID,Value from Styles'
                   cursor.execute(sql)
                   rows = cursor.fetchall()
                   for row in rows: styles.append(row[1])
                   if 0 == len(rows): rows.append('fusion')
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
               return styles
           '''
               @brief  Set current Project
               @history    2018.06.27  Jeongwoo    If DB file is not, copy DB file from ProgramData
           '''
           def setCurrentProject(self, project):
               self.project = project
               self.makeChildDir()
               self.copySvg()
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath() , App.NAME + '.db')
                   if not os.path.isfile(dbPath):
                       templatePath = self.getTemplateDbPath()
                       templateFile = QFile(templatePath)
                       templateFile.copy(dbPath)
                   else:
                       try:
                           conn = sqlite3.connect(dbPath)
                           # Get a cursor object
                           cursor = conn.cursor()
                           fileNames = os.listdir(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'Scripts'))
                           for fileName in fileNames:
                               if fileName.endswith(".sql") and (1 == len(os.path.splitext(fileName)[0].split('.'))):
                                   try:
                                       file = QFile(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'Scripts', fileName))
                                       file.open(QFile.ReadOnly)
                                       sql = file.readAll()
                                       sql = str(sql, encoding='utf8')
                                       cursor.executescript(sql)
                                   finally:
                                       file.close()
                           conn.commit()
                       except Exception as ex:
                           print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
                       finally:
                           conn.close()
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   pass
           '''
               @brief      Copy Svg
               @author     yeonjin
               @date       19.07.31
           '''
           def copySvg(self):
               from shutil import copyfile
               path = os.path.join(os.getenv('ALLUSERSPROFILE'), App.NAME)
               sourceDir = os.path.join(path, 'svg')
               if not os.path.exists(sourceDir):
                   return
               project = AppDocData.instance().getCurrentProject()
               targetDir = project.getSvgFilePath()
               for root, dirs, files in os.walk(sourceDir):
                   for file in files: # loops through directories and files
                       sourceFile = os.path.join(root, file)
                       targetFile = sourceFile.replace(sourceDir, targetDir)
                       if not os.path.exists(targetFile):
                           dir = os.path.dirname(targetFile)
                           if not os.path.exists(dir):
                               os.makedirs(dir)
                           copyfile(sourceFile, targetFile)
           '''
               @brief      Make Directory
               @author     Jeongwoo
               @date       18.05.08
               @history    humkyung 2018.06.19 make 'Tile' directory
                           humkyung 2018.07.09 make drawing folder if not exists
                           euisung 2018.09.28 make training folder if not exists
           '''
           def makeChildDir(self):
               project = AppDocData.instance().getCurrentProject()
               dbDir = project.getDbFilePath()
               if not os.path.exists(dbDir):
                   os.makedirs(dbDir)
               imgDir = project.getImageFilePath()
               if not os.path.exists(imgDir):
                   os.makedirs(imgDir)
               svgDir = project.getSvgFilePath()
               if not os.path.exists(svgDir):
                   os.makedirs(svgDir)
               outputDir = project.getOutputPath()
               if not os.path.exists(outputDir):
                   os.makedirs(outputDir)
               tempDir = project.getTempPath()
               if not os.path.exists(tempDir):
                   os.makedirs(tempDir)
               drawingPath = project.getDrawingFilePath()
               if not os.path.exists(drawingPath):
                   os.makedirs(drawingPath)
               trainingPath = project.getTrainingFilePath()
               if not os.path.exists(trainingPath):
                   os.makedirs(trainingPath)
               path = os.path.join(tempDir, 'Tile')
               if not os.path.exists(path):
                   os.makedirs(path)
               borderDir = project.getBorderFilePath()
               if not os.path.exists(borderDir):
                   os.makedirs(borderDir)
           '''
               @brief  Get current Project
           '''
           def getCurrentProject(self):
               return self.project
           '''
               @brief      return project database path
               @history    humkyung 2018.04.19 return Project.db in Program Data folder instead of PROJECT_DB_PATH variable
           '''
           def getPrjDatabasePath(self):
               path = os.path.join(os.getenv('ALLUSERSPROFILE'), App.NAME)
               if not os.path.exists(path): os.makedirs(path)
               prjDatabaseFilePath = os.path.join(path, 'Project.db')
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   conn = sqlite3.connect(prjDatabaseFilePath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   filePath = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'Scripts', 'Project.Projects.sql')
                   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:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
               return prjDatabaseFilePath
           def getErrorItemSvgPath(self):
               '''
                   @brief  return error item svg path
                   @author euisung
                   @date   2019.04.02
               '''
               return os.path.join(os.getenv('ALLUSERSPROFILE'), App.NAME, 'Explode.svg')
           def updateTitleBlockProperties(self, titleBlockProps):
               '''
                   @brief  update title block properties
                   @author euisung
                   @date   2018.11.09
               '''
               try:
                   for titleBlockProp in titleBlockProps:
                       titleBlockProp[1] = self.imgName + '!@!' + titleBlockProp[1]
                   originTitleBlockProps = self.getTitleBlockProperties()
                   deletedTitleBlockProps = []
                   for originTitleBlockProp in originTitleBlockProps:
                       for titleBlockProp in titleBlockProps:
                           # uid compare for determine delete props
                           if originTitleBlockProp[0] == titleBlockProp[0]:
                               break
                       deletedTitleBlockProps.append(originTitleBlockProp[0])
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   for deletedTitleBlockProp in deletedTitleBlockProps:
                       sql = "delete from TitleBlockProperties where UID='{}'".format(deletedTitleBlockProp)
                       cursor.execute(sql)
                   for titleBlockProp in titleBlockProps:
                       sql = "insert or replace into TitleBlockProperties values(?,?,?)"
                       param = (titleBlockProp[0], titleBlockProp[1], titleBlockProp[2]) # uid, name, area
                       cursor.execute(sql, param)
                   conn.commit()
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
               self._titleBlockProperties = None
           def getTitleBlockProperties(self):
               '''
                   @brief  return title block properties
                   @author euisung
                   @date   2018.11.09
               '''
               res = None
               if True:#self._titleBlockProperties is None:
                   try:
                       self._titleBlockProperties = []
                       # Creates or opens a file called mydb with a SQLite3 DB
                       dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                       db = sqlite3.connect(dbPath)
                       # Get a cursor object
                       cursor = db.cursor()
                       sql = "select UID, Name, AREA from TitleBlockProperties"
                       cursor.execute(sql)
                       rows = cursor.fetchall()
                       for row in rows:
                           if row[1].split('!@!')[0] != self.imgName:
                               continue
                           else:
                               attr = []
                               attr.append(row[0]) # uid
                               attr.append(row[1].split('!@!')[1]) # name
                               attr.append(row[2]) # area
                               self._titleBlockProperties.append(attr)
                       res = self._titleBlockProperties
                   # Catch the exception
                   except Exception as ex:
                       # Roll back any change if something goes wrong
                       db.rollback()
                       print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
                   finally:
                       # Close the db connection
                       db.close()
               else:
                   res = self._titleBlockProperties
               return res
           def clearLineNoProperties(self):
               self._lineNoProperties = None
           '''
               @brief  return line properties
               @author humkyung
               @date   2018.04.09
           '''
           def getLineProperties(self):
               from SymbolAttr import SymbolAttr
               res = None
               if self._lineNoProperties is None:
                   try:
                       self._lineNoProperties = []
                       # Creates or opens a file called mydb with a SQLite3 DB
                       dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                       db = sqlite3.connect(dbPath)
                       # Get a cursor object
                       cursor = db.cursor()
                       sql = "select UID, Name, DisplayName, Type, LimitNumber, [index] from LineProperties order by [index]"
                       cursor.execute(sql)
                       rows = cursor.fetchall()
                       for row in rows:
                           attr = SymbolAttr()
                           attr.UID = row[0]
                           attr.Attribute = row[1]
                           attr.DisplayAttribute = row[2]
                           attr.AttributeType = row[3]
                           attr.Length = row[4]
                           self._lineNoProperties.append(attr)
                       res = self._lineNoProperties
                   # Catch the exception
                   except Exception as ex:
                       # Roll back any change if something goes wrong
                       db.rollback()
                       print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
                   finally:
                       # Close the db connection
                       db.close()
               else:
                   res = self._lineNoProperties
               return res
           '''
               @brief  return line properties
               @author humkyung
               @date   2018.04.09
           '''
           def getLinePropertiesByUID(self, UID):
               from SymbolAttr import SymbolAttr
               res = []
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   db = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = db.cursor()
                   sql = "select UID, Name, DisplayName, Type, LimitNumber, [index] from LineProperties where uid = '{}'".format(UID)
                   cursor.execute(sql)
                   rows = cursor.fetchall()
                   for row in rows:
                       attr = SymbolAttr()
                       attr.UID = row[0]
                       attr.Attribute = row[1]
                       attr.DisplayAttribute = row[2]
                       attr.AttributeType = row[3]
                       attr.Length = row[4]
                       res.append(attr)
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   db.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   db.close()
               return res
           '''
               @brief  return line types
               @author humkyung
               @date   2018.06.27
           '''
           def getLineTypes(self):
               from LineTypeConditions import LineTypeConditions
               res = []
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   db = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = db.cursor()
                   sql = "select UID,Name,Type1,Conditions1,Type2,Conditions2 from LineTypes order by Name"
                   cursor.execute(sql)
                   rows = cursor.fetchall()
                   for row in rows:
                       line_type = LineTypeConditions(row[0], row[1])
                       line_type._conditions[0][0] = row[2]
                       line_type._conditions[0][1] = row[3]
                       line_type._conditions[1][0] = row[4]
                       line_type._conditions[1][1] = row[5]
                       res.append(line_type)
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   db.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   db.close()
               return res
           '''
               @brief      Insert New Project Info
               @author     Jeongwoo
               @date       2018.04.06
               @history    humkyung 2018.04.19 use getPrjDatabasePath function instead of PROJECT_DB_PATH variable
           '''
           def insertProjectInfo(self, desc, dir):
               try:
                   prjDatabaseFilePath = self.getPrjDatabasePath()
                   conn = sqlite3.connect(prjDatabaseFilePath)
                   folderName = dir.split('/')[-1]
                   if folderName:
                       nowDate = datetime.datetime.now().strftime('%Y.%m.%d %H:%M')
                       sql = "insert or replace into Projects(Name, [Desc], Path, CreatedDate, UpdatedDate) values(?, ?, ?, ?, ?)"
                       param = (folderName, desc, dir, nowDate, nowDate)
                       cursor = conn.cursor()
                       cursor.execute(sql, param)
                       conn.commit()
                   else:
                       print("Empty folder name")
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   conn.close()
           def removeProjectInfo(self, targetProject):
               '''
               @brief      Remove Project Info
               @author     Euisung
               @date       2019.01.28
               '''
               try:
                   prjDatabaseFilePath = self.getPrjDatabasePath()
                   conn = sqlite3.connect(prjDatabaseFilePath)
                   sql = "delete from Projects where Id = '{}'".format(targetProject.id)
                   cur = conn.cursor()
                   cur.execute(sql)
                   conn.commit()
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   conn.close()
           '''
               @brief      Update Project UpdatedDate Field
               @author     Jeongwoo
               @date       2018.04.06
               @history    humkyung 2018.04.19 use getPrjDatabasePath function instead of PROJECT_DB_PATH variable
           '''
           def updateProjectUpdatedDate(self, id, desc):
               try:
                   prjDatabaseFilePath = self.getPrjDatabasePath()
                   conn = sqlite3.connect(prjDatabaseFilePath)
                   nowDate = datetime.datetime.now().strftime('%Y.%m.%d %H:%M')
                   sql = '''
                       UPDATE Projects
                       SET UpdatedDate = ?,[Desc]=?
                       WHERE Id = ?
                   '''
                   cur = conn.cursor()
                   cur.execute(sql, (nowDate, desc, id))
                   conn.commit()
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   conn.close()
           '''
               @brief  get project list from database
               @history    humkyung 2018.04.18 add only project which's project exists
           '''
           def getProjectList(self):
               from Project import Project
               projectList = []
               try:
                   conn = sqlite3.connect(self.getPrjDatabasePath())
                   cursor = conn.cursor()
                   sql = 'SELECT id,name,[desc],path,createddate,updateddate  FROM Projects ORDER BY UpdatedDate DESC'
                   try:
                       cursor.execute(sql)
                       rows = cursor.fetchall()
                       for row in rows:
                           if os.path.isdir(row[3]):   # check if folder exists
                               projectList.append(Project(row[0], row[1], desc=row[2], path=row[3], createDate=row[4], updateDate=row[5]))
                   except Exception as ex:
                       print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   conn.close()
               return projectList
           '''
               @brief  get sliding window size
               @author humkyung
           '''
           def getSlidingWindowSize(self):
               res = [10,15]
               try:
                   configs = self.getConfigs('Sliding Window')
                   for config in configs:
                       if config.key == 'Width':
                           res[0] = int(config.value)
                       elif config.key == 'Height':
                           res[1] = int(config.value)
               # Catch the exception
               except Exception as ex:
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               return res
           '''
               @brief  get line no configuration
               @author humkyung
               @date   2018.04.16
           '''
           def getLineNoConfiguration(self):
               res = None
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   delimiter = None
                   sql = "select * from configuration where section='Line No' and key='Delimiter"
                   cursor.execute(sql)
                   rows = cursor.fetchall()
                   if len(rows) == 1:
                       delimiter = rows[0][2]
                   if delimiter is not None:
                       sql = "select * from configuration where section='Line No' and key='Configuration'"
                       cursor.execute(sql)
                       rows = cursor.fetchall()
                       if len(rows) == 1:
                           res = rows[0][2].split(delimiter)
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
               return res
           '''
               @brief  get area list
               @author humkyung
               @history    euisung     2018.11.20 (0,0),(0,0) process add
           '''
           def getAreaList(self):
               from Area import Area
               if len(self._areas) == 0:
                   try:
                       # Creates or opens a file called mydb with a SQLite3 DB
                       dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                       conn = sqlite3.connect(dbPath)
                       # Get a cursor object
                       cursor = conn.cursor()
                       sql = "select * from configuration where section='Area'"
                       cursor.execute(sql)
                       rows = cursor.fetchall()
                       for row in rows:
                           name = row[1]
                           area = Area(name)
                           area.parse(row[2])
                           self._areas.append(area)
                   # Catch the exception
                   except Exception as ex:
                       # Roll back any change if something goes wrong
                       conn.rollback()
                       print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
                   finally:
                       # Close the db connection
                       conn.close()
               return self._areas
           '''
               @brief  get area of given name
               @author humkyung
               @date   2018.04.07
           '''
           def getArea(self, name):
               areas = self.getAreaList()
               matches = [area for area in areas if area.name==name]
               if 1 == len(matches) and matches[0].height is not 0 and matches[0].width is not 0:
                   return matches[0]
               return None
           '''
               @brief  get configurations
               @author humkyung
               @date   2018.04.16
               @history kyouho 2018.07.09 change query method
           '''
           '''
           def getConfigs(self, section, key=None):
               res = []
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # 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:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
               return res
               '''
           def getConfigs(self, section, key=None):
               res = []
               if self.configTable is None:
                   self.configTable = []
                   try:
                       # Creates or opens a file called mydb with a SQLite3 DB
                       dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                       conn = sqlite3.connect(dbPath)
                       # Get a cursor object
                       cursor = conn.cursor()
                       sql = "select Section, Key, Value from configuration"
                       cursor.execute(sql)
                       rows = cursor.fetchall()
                       for row in rows:
                           self.configTable.append(Config(row[0], row[1], row[2]))
                       # Catch the exception
                   except Exception as ex:
                       # Roll back any change if something goes wrong
                       conn.rollback()
                       print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
                   finally:
                       # Close the db connection
                       conn.close()
               if key is not None:
                   for con in self.configTable:
                       if con.section == section and con.key == key:
                           res.append(con)
               else:
                   for con in self.configTable:
                       if con.section == section:
                           res.append(con)
               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()
                   conn = sqlite3.connect(dbPath)
                   # 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:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
               return res
           '''
               @brief      save configurations
               @author     humkyung
               @date       2018.04.16
               @history    humkyung 2018.07.03 replace ' with " if value has '
                           kyouho 2018.07.09 change query method
           '''
           def saveConfigs(self, configs):
               import uuid
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath, isolation_level=None)
                   # Get a cursor object
                   cursor = conn.cursor()
                   for config in configs:
                       if type(config) is Config:
                           value = config.value
                           if type(value) is str and "'" in value:
                               value = value.replace("'", "''")
                           sql = "insert or replace into configuration values(?,?,?,?)"
                           param = (str(uuid.uuid4()), config.section, config.key, value)
                           cursor.execute(sql, param)
                       elif hasattr(config, 'toSql'):
                           sql = config.toSql()
                           if type(sql) is list:
                               for item in sql:
                                   if item is not None and 2 == len(item):
                                       cursor.execute(item[0], item[1])
                           else:
                               if sql is not None and 2 == len(sql):
                                   cursor.execute(sql[0], sql[1])
                   conn.commit()
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
           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()
                   conn = sqlite3.connect(dbPath)
                   # 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:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
           def deleteDrawingByUID(self, uid):
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   # 0. Delete Points
                   sql = "delete from Points where Components_UID in (select UID from Components where Drawings_UID = '{}')".format(uid)
                   cursor.execute(sql)
                   # 1. Delete HMB
                   sql = "delete from HMB where Components_UID in (select UID from Components where Drawings_UID = '{}')".format(uid)
                   cursor.execute(sql)
                   # 2. Delete Components
                   sql = "delete from Components where Drawings_UID='{}'".format(uid)
                   cursor.execute(sql)
                   # 3. Delete DrawingsUnits
                   sql = "delete from DrawingsUnits where Drawings_UID='{}'".format(uid)
                   cursor.execute(sql)
                   # 4. Delete Drawings
                   sql = "delete from Drawings where UID='{}'".format(uid)
                   cursor.execute(sql)
                   conn.commit()
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
           '''
               @brief  delete configurations
               @author humkyung
               @date   2018.06.29
           '''
           def deleteConfigs(self, section, key=None):
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # 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:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
           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)
                   # 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:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
           '''
               @brief      set area list
               @history    humkyung 2018.05.18 round area coordinate and dimension before saving
               @history    euisung  2018.11.20 add self._area reset process
           '''
           def setAreaList(self, areas):
               for area in areas:
                   matches = [x for x in self._areas if x.name==area.name]
                   if 1 == len(matches):
                       matches[0].x = area.x
                       matches[0].y = area.y
                       matches[0].width = area.width
                       matches[0].height = area.height
                   elif 0 == len(matches):
                       self._areas.append(area)
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   for area in self._areas:
                       sql = "insert or replace into configuration values('Area','{}','({},{}),({},{})')".format(area.name, round(area.x), round(area.y), round(area.width), round(area.height))
                       cursor.execute(sql)
                   conn.commit()
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   self._areas = []
                   conn.close()
           '''
               @brief  get symbol name list
           '''
           def getSymbolNameList(self):
               symbolNametList = []
               try:
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   cursor = conn.cursor()
                   sql = 'SELECT * FROM SymbolName'
                   try:
                       cursor.execute(sql)
                       rows = cursor.fetchall()
                       for row in rows:
                           symbolNametList.append(row[4]) # Name String
                   except Exception as ex:
                       print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   conn.close()
               return symbolNametList
           '''
               @brief      get symbol name list by symbol Type
               @author     Jeongwoo
               @date       18.04.06
               @history    .
           '''
           def getSymbolNameListByType(self, type):
               symbolNametList = []
               try:
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   cursor = conn.cursor()
                   sql = ''
                   if type is not None:
                       sql = 'SELECT * FROM SymbolName WHERE type = "' + type + '"'
                       try:
                           cursor.execute(sql)
                           rows = cursor.fetchall()
                           for row in rows:
                               symbolNametList.append(row[4]) # Name String
                       except Exception as ex:
                           print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   conn.close()
               return symbolNametList
           '''
               @brief  delete added symbol data
           '''
           def deleteSymbol(self, fileName):
               ret = False
               try:
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   cursor = conn.cursor()
                   sql = "DELETE FROM Symbol WHERE name = ?"
                   try:
                       cursor.execute(sql, (fileName,))
                       conn.commit()
                       ret = True
                   except Exception as ex:
                       print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
                       ret = False
               finally:
                   conn.close()
                   return (ret, fileName)
           '''
               @brief  get symbol name
               @history    18.04.24    Jeongwoo    Add isExceptDetect Field
           '''
           def getSymbolByQuery(self, fieldName, param):
               ret = None
               try:
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   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:
                       print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   conn.close()
               return ret
           def getSymbolListByUID(self, uid):
               ret = []
               try:
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   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:
                       print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   conn.close()
               return ret
           '''
               @brief  get symbol name list
               @history    18.04.24    Jeongwoo    Add isExceptDetect Field
           '''
           def getSymbolListByType(self, fieldName=None, param=None):
               ret = []
               try:
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   cursor = conn.cursor()
                   if fieldName is not None and param is not None:
                       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 = (select UID from SymbolType where Type=?)"""
                   else:
                       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"""
                   try:
                       cursor.execute(sql, (param,)) if param is not None else cursor.execute(sql)
                       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:
                       print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   conn.close()
               return ret
           '''
               @brief      get NominalDiameter
               @author     humkyung
               @date       2018.04.20
               @history    humkyung 2018.04.24 read MetricStr column and set size unit
                           kyouho 2018.07.04 forCheckLineNumber get only inch or metric
                           kyouho 2018.07.16 edit query order by code
           '''
           def getNomialPipeSizeData(self, forCheckLineNumber = False, orderStr = "CODE"):
               res = []
               try:
                   configs = self.getConfigs('Line No', 'Size Unit')
                   sizeUnit = configs[0].value if 1 == len(configs) else 'Metric'
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = "select UID,Code,Metric,Inch,InchStr,AllowableInchStr,MetricStr,AllowableMetricStr from NominalDiameter ORDER BY {} ASC".format(orderStr)
                   cursor.execute(sql)
                   rows = cursor.fetchall()
                   for row in rows:
                       pipeSize = NominalPipeSize(row[0], row[1], float(row[2]) if row[2] else None, float(row[3]) if row[3] else None, row[4], row[5], row[6], row[7])
                       pipeSize.sizeUnit = sizeUnit
                       if forCheckLineNumber:
                           if sizeUnit == 'Inch' and pipeSize.inchStr:
                               res.append(pipeSize.inchStr)
                           elif sizeUnit == 'Metric' and pipeSize.metricStr:
                               res.append(pipeSize.metricStr)
                       else:
                           res.append(pipeSize)
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   from App import App
                   message = 'error occured({}) 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
           '''
               @brief      insert NominalDiameter table
               @author     kyouho
               @date       2018.07.16
           '''
           def insertNomialPipeSize(self, pipeSizes):
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   for pipeSize in pipeSizes:
                       sql = pipeSize.toSql()
                       if type(sql) is list and len(sql) == 1:
                           cursor.execute(sql[0][0], sql[0][1])
                   conn.commit()
                   # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
           '''
               @brief      delete NominalDiameter table
               @author     kyouho
               @date       2018.07.16
           '''
           def deleteNomialPipeSize(self):
               try:
                   dbPath = os.path.join(self.getCurrentProject().getPath(), 'db', AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   cursor = conn.cursor()
                   sql = "DELETE FROM NominalDiameter"
                   try:
                       cursor.execute(sql)
                       conn.commit()
                   except Exception as ex:
                       print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   conn.close()
           '''
               @brief      convert inch to metric
               @author     kyouho
               @date       2018.07.09
           '''
           def convertInchToMetric(self, inch):
               result = ''
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = "select MetricStr from NominalDiameter WHERE InchStr = ?"
                   param = (inch,)
                   cursor.execute(sql, param)
                   rows = cursor.fetchall()
                   if rows:
                       result = rows[0][0]
                   # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
               return result
           '''
               @brief      get Color MaxUID
               @author     kyouho
               @date       2018.07.03
           '''
           def getMaxColorUID(self):
               result = 0
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = "select MAX(UID) from Colors"
                   cursor.execute(sql)
                   rows = cursor.fetchall()
                   result = rows[0][0]
                   # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
               return result
           '''
               @brief      insert Color property
               @author     kyouho
               @date       2018.07.09
           '''
           def setPropertyColor(self, _color):
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = "INSERT INTO Colors(UID, RED, GREEN, BLUE, PROPERTY, VALUE) VALUES(?,?,?,?,?,?)"
                   param = (_color.index, _color.red, _color.green, _color.blue, _color._property, _color.value)
                   cursor.execute(sql, param)
                   conn.commit()
                   # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
           '''
               @brief      delete Color property
               @author     kyouho
               @date       2018.07.09
           '''
           def deletePropertyColor(self, property):
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = "DELETE FROM Colors WHERE PROPERTY = '{}'".format(property)
                   cursor.execute(sql)
                   conn.commit()
                   # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
           '''
               @brief      get Fluid Code
               @author     kyouho
               @date       2018.07.03
               @history    kyouho 2018.07.04 kyouho 2018.07.04 forCheckLineNumber get only code
           '''
           def getFluidCodeData(self, forCheckLineNumber = False):
               from FluidCodeData import FluidCodeData
               result = []
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = 'select uid, code, description from FluidCode order by length(code) DESC'
                   cursor.execute(sql)
                   rows = cursor.fetchall()
                   for row in rows:
                       data = FluidCodeData(row[0], row[1], row[2])
                       if forCheckLineNumber:
                           result.append(data.code)
                       else:
                           result.append(data)
                   # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
               return result
           '''
               @brief      get Symbol Attribute
               @author     kyouho
               @date       2018.07.18
           '''
           def checkAttribute(self, attr):
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = 'select UID from SymbolAttribute where UID = ?'
                   param = (attr,)
                   cursor.execute(sql, param)
                   rows = cursor.fetchall()
                   if len(rows):
                       return True
                   else:
                       return False
                   # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
               return False
           '''
               @brief      get Symbol Attribute
               @author     kyouho
               @date       2018.07.18
               @history    humkyung 2018.10.13 load expression
           '''
           def getSymbolAttribute(self, _type):
               import uuid
               from SymbolAttr import SymbolAttr
               result = []
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = 'select a.UID, a.Attribute, a.DisplayAttribute, a.AttributeType, a.[AttrAt], a.[Expression], a.[index], a.[Target], a.[Property] from SymbolAttribute a inner join SymbolType t on a.SymbolType_UID = t.UID and t.type = ? order by a.[index]'
                   param = (_type,)
                   cursor.execute(sql, param)
                   rows = cursor.fetchall()
                   for row in rows:
                       attr = SymbolAttr()
                       attr.UID = uuid.UUID(row[0], version=4)
                       attr.Attribute = row[1]
                       attr.DisplayAttribute = row[2]
                       attr.AttributeType = row[3]
                       attr.AttrAt = row[4]
                       attr.Expression = row[5]
                       attr.Target = row[7]
                       attr.IsProp = bool(row[8])
                       result.append(attr)
                   # Catch the exception
               except Exception as ex:
                   from App import App
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   message = 'error occured({}) 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 result
           '''
               @brief      get Symbol Attribute by UID
               @author     kyouho
               @date       2018.08.17
               @history    humkyung 2018.10.13 load expression
           '''
           def getSymbolAttributeByUID(self, UID):
               from SymbolAttr import SymbolAttr
               res = None
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = 'select Attribute, DisplayAttribute, AttributeType, AttrAt, Expression, Target, Property from SymbolAttribute where uid = "{}"'.format(UID)
                   cursor.execute(sql)
                   rows = cursor.fetchall()
                   if len(rows):
                       res = SymbolAttr()
                       res.UID = UID
                       res.Attribute = rows[0][0]
                       res.DisplayAttribute = rows[0][1]
                       res.AttributeType = rows[0][2]
                       res.AttrAt = rows[0][3]
                       res.Expression = rows[0][4]
                       res.Target = rows[0][5]
                       res.IsProp = bool(row[0][6])
                   # Catch the exception
               except Exception as ex:
                   from App import App
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   message = 'error occured({}) 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
           '''
               @brief      save symbol attributes
               @author     humkyung
               @date       2018.08.14
               @history    humkyung 2018.10.13 save expression
           '''
           def saveSymbolAttributes(self, type, attrs):
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = 'delete from SymbolAttribute where SymbolType_UID = ?'
                   param = (type,)
                   cursor.execute(sql, param)
                   for attr in attrs:
                       sql = 'insert into SymbolAttribute(UID, SymbolType_UID, Attribute, DisplayAttribute, AttributeType, AttrAt, Expression, Target, [index]) values(?, ?, ?, ?, ?, ?, ?, ?, ?)'
                       attr.insert(1, type)
                       param = tuple(attr)
                       cursor.execute(sql, param)
                   conn.commit()
                   # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   from App import App
                   message = 'error occured({}) 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      save symbol attributes
               @author     humkyung
               @date       2018.08.14
           '''
           def saveLineAttributes(self, attrs):
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = 'delete from LineProperties'
                   cursor.execute(sql)
                   for attr in attrs:
                       sql = 'insert into LineProperties(UID, Name, DisplayName, Type, LimitNumber, [index]) values(?, ?, ?, ?, ?, ?)'
                       param = tuple(attr)
                       cursor.execute(sql, param)
                   conn.commit()
                   self._lineNoProperties = None
                   # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   from App import App
                   message = 'error occured({}) 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 type id
               @author     kyouho
               @date       2018.08.17
           '''
           def getSymbolTypeId(self, symbolType):
               result = []
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = 'select UID from SymbolType where Type = ?'
                   param = (symbolType,)
                   cursor.execute(sql, param)
                   rows = cursor.fetchall()
                   if len(rows):
                       result = rows[0][0]
                   else:
                       result = -1
                   # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
               return result
           '''
               @brief      get Code Table Data
               @author     kyouho
               @date       2018.07.10
           '''
           def getCodeTable(self, property, forCheckLineNumber = False):
               result = []
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   if property.upper().replace(' ','') == "NOMINALDIAMETER" and forCheckLineNumber:
                       sql = 'select InchStr, MetricStr from [{}] order by Metric ASC'.format(property)
                       cursor.execute(sql)
                       rows = cursor.fetchall()
                       for index in range(2):
                           for row in rows:
                               if row[index] != '' and result.count(row[index].replace("'", '"')) == 0:
                                   result.append(row[index].replace("'", '"'))
                   else:
                       sql = 'select uid, code, description, Allowables from [{}] order by length(code) DESC'.format(property)
                       cursor.execute(sql)
                       rows = cursor.fetchall()
                       for row in rows:
                           if forCheckLineNumber:
                               data = row[1]
                           else:
                               data = (row[0], row[1], row[2], row[3])
                           result.append(data)
                   # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
               return result
           '''
               @brief      Set Common Code Data
               @author     kyouho
               @date       2018.07.12
           '''
           def saveCommonCodeData(self, tableName, datas):
               import uuid
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   for data in datas:
                       uid,code,description,allowables = data[0],data[1],data[2],data[3]
                       if not uid:
                           sql = "insert or replace into {}(UID, CODE, DESCRIPTION, ALLOWABLES) values(?, ?, ?, ?)".format(tableName)
                           param = (str(uuid.uuid4()), data[1], data[2], data[3])
                       elif uid == '-1':
                           sql = 'delete from {} where uid=?'.format(tableName)
                           param = (data[-1],)
                       else:
                           sql = "update {} SET CODE=?, DESCRIPTION=?, ALLOWABLES=? WHERE UID = ?".format(tableName)
                           param = (data[1], data[2], data[3], data[0])
                       cursor.execute(sql, param)
                   conn.commit()
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}:{}) in {}:{}'.format(tableName, ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
           '''
               @brief      Set Common Code Data
               @author     kyouho
               @date       2018.07.12
           '''
           def deleteCommonCodeData(self, datas):
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   for data in datas:
                       uid = data[0]
                       tableName = data[1]
                       if uid:
                           sql = "delete from {} where UID = ?".format(tableName)
                           param = (uid,)
                           cursor.execute(sql, param)
                       cursor.execute(sql, param)
                   conn.commit()
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
           '''
               @brief      delete data list
               @author     kyouho
               @date       2018.08.16
           '''
           def deleteDataList(self, tableName, UID):
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = 'delete from {} where UID = {}'.format(tableName, UID)
                   cursor.execute(sql)
                   conn.commit()
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
           def getDocumentNameList(self):
               '''
                   @brief      get documentName list
                   @author     euisung
                   @date       2018.12.11
               '''
               result = []
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = 'select DISTINCT(PNID_NO) from LINE_DATA_LIST'
                   cursor.execute(sql)
                   sql = 'select DISTINCT(PNID_NO) from EQUIPMENT_DATA_LIST'
                   cursor.execute(sql)
                   sql = 'select DISTINCT(PNID_NO) from INSTRUMENT_DATA_LIST'
                   cursor.execute(sql)
                   sql = 'select DISTINCT(PNID_NO) from NOTE_DATA_LIST'
                   cursor.execute(sql)
                   sql = 'select DISTINCT(PNID_NO) from VALVE_DATA_LIST'
                   cursor.execute(sql)
                   rows = cursor.fetchall()
                   for row in rows:
                       result.append(row[0])
                   result = list(set(result))
                   result.sort()
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
               return result
           '''
               @brief      get line documentName list
               @author     kyouho
               @date       2018.08.13
           '''
           def getLineDocumentNameList(self):
               result = []
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = 'select DISTINCT(PNID_NO) from LINE_DATA_LIST'
                   cursor.execute(sql)
                   rows = cursor.fetchall()
                   for row in rows:
                       result.append(row[0])
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
               return result
           '''
               @brief      get line documentName list
               @author     kyouho
               @date       2018.08.14
           '''
           def getEquipDocumentNameList(self):
               result = []
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = 'select DISTINCT(PNID_NO) from EQUIPMENT_DATA_LIST'
                   cursor.execute(sql)
                   rows = cursor.fetchall()
                   for row in rows:
                       result.append(row[0])
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
               return result
           '''
               @brief      get line data list
               @author     kyouho
               @date       2018.08.13
           '''
           def getLineDataList(self, docName = None):
               result = []
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = 'select 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 from LINE_DATA_LIST'
                   if docName is not None:
                       sql += " where PNID_NO = '{}'".format(docName)
                   cursor.execute(sql)
                   #columnName = list(map(lambda x: x[0].upper(), cursor.description))
                   rows = cursor.fetchall()
                   for row in rows:
                       data = []
                       for index in range(len(cursor.description)):
                           data.append(row[index])
                       result.append(data)
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
               return result
           '''
               @brief      set line data list
               @author     kyouho
               @date       2018.08.13
           '''
           def setLineDataList(self, dataLists):
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   for data in dataLists:
                       sql = "insert or replace into LINE_DATA_LIST(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) values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
                       param = tuple(data)
                       cursor.execute(sql, param)
                   conn.commit()
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
           '''
               @brief      delete line data list
               @author     kyouho
               @date       2018.08.13
           '''
           def deleteLineDataList(self, removeUID):
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   for uid in removeUID:
                       sql = "delete from LINE_DATA_LIST where uid = '{}'".format(uid)
                       cursor.execute(sql)
                   conn.commit()
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
           '''
               @brief      delete line data list
               @author     kyouho
               @date       2018.08.13
           '''
           def deleteLineDataList_LineNo(self, removeUID):
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   for uid in removeUID:
                       sql = "delete from LINE_DATA_LIST where LINE_NO = ?"
                       param = (uid,)
                       cursor.execute(sql, param)
                   conn.commit()
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
           '''
               @brief      delete equip data list
               @author     kyouho
               @date       2018.08.14
           '''
           def deleteEquipDataList(self, removeUID):
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   for uid in removeUID:
                       sql = "delete from EQUIPMENT_DATA_LIST where uid = '{}'".format(uid)
                       cursor.execute(sql)
                   conn.commit()
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
           '''
               @brief      delete inst data list
               @author     kyouho
               @date       2018.08.14
           '''
           def deleteInstDataList(self, removeUID):
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   for uid in removeUID:
                       sql = "delete from INSTRUMENT_DATA_LIST where uid = '{}'".format(uid)
                       cursor.execute(sql)
                   conn.commit()
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
           '''
               @brief      delete note data list
               @author     kyouho
               @date       2018.10.10
           '''
           def deleteNoteDataList(self, removeUID):
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   for uid in removeUID:
                       sql = "delete from NOTE_DATA_LIST where uid = '{}'".format(uid)
                       cursor.execute(sql)
                   conn.commit()
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
           '''
               @brief      get equipment data list
               @author     humkyung
               @date       2018.05.03
           '''
           def getEquipmentDataList(self, docName = None):
               result = []
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = 'select a.*,C.Attribute,B.Value  from EQUIPMENT_DATA_LIST a left join Attributes B on a.UID=B.Components_UID ' \
                                                                                    'left join SymbolAttribute C on B.SymbolAttribute_UID=C.UID'
                   if docName is not None:
                       sql += " where PNID_NO = '{}'".format(docName)
                   cursor.execute(sql)
                   col_names = [desc[0] for desc in cursor.description]    # get coloumn name
                   rows = cursor.fetchall()
                   for row in rows:
                       matches = [res for res in result if res['UID']==row[0]]
                       if matches:
                           matches[0][row[len(row)-2]] = row[len(row)-1]
                       else:
                           data = dict(zip(col_names[:-2], row[:-2]))
                           if row[len(row)-2] is not None:
                               data[row[len(row)-2]] = row[len(row)-1]
                           result.append(data)
               # Catch the exception
               except Exception as ex:
                   from App import App
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   message = 'error occured({}) 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 result
           def get_valve_data_list(self, docName = None):
               """
               @brief      get valve data list
               @author     humkyung
               @date       2018.10.11
               """
               result = []
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = 'select a.UID,a.ITEM_NO,a.PNID_NO,a.MainSize,a.SubSize,c.Attribute,b.Value from VALVE_DATA_LIST a left join Attributes b on a.uid=b.Components_UID ' \
                         'left join SymbolAttribute c on b.SymbolAttribute_UID=c.UID'
                   if docName is not None:
                       sql += " where PNID_NO = '{}'".format(docName)
                   cursor.execute(sql)
                   rows = cursor.fetchall()
                   for row in rows:
                       matches = [res for res in result if res['UID'] == row[0]]
                       if matches:
                           matches[0][row[5]] = row[6]
                       else:
                           data = {'UID':row[0], 'ITEM_NO':row[1], 'PNID_NO':row[2], 'MainSize':row[3], 'SubSize':row[4]}
                           data[row[5]] = row[6]
                           result.append(data)
               # Catch the exception
               except Exception as ex:
                   from App import App
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   message = 'error occured({}) 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 result
           '''
               @brief      get instrument data list
               @author     kyouho
               @date       2018.08.14
           '''
           def getInstrumentDataList(self, docName = None):
               result = []
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   #sql = 'select UID, ITEM_NO, SERVICE, FLOW_RATE, PRESSURE, TEMPERATURE, TYPE, RANGE, NOR_LEVEL_MM, NOR_LEVEL_PERCENT, DEL_PRESS, SHUT_OFF, LOCATION, PNID_NO, REV from INSTRUMENT_DATA_LIST'
                   sql = 'select * from INSTRUMENT_DATA_LIST'
                   if docName is not None:
                       sql += " where PNID_NO = '{}'".format(docName)
                   cursor.execute(sql)
                   rows = cursor.fetchall()
                   for row in rows:
                       data = []
                       for index in range(len(cursor.description)):
                           data.append(row[index])
                       result.append(data)
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   from App import App
                   message = 'error occured({}) 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 result
           '''
               @brief      get Note data list
               @author     kyouho
               @date       2018.10.10
           '''
           def getNoteDataList(self, docName = None):
               result = []
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = 'select UID, NOTE_NO, DESCRIPTION, PNID_NO from NOTE_DATA_LIST'
                   if docName is not None:
                       sql += " where PNID_NO = '{}'".format(docName)
                   sql += ' ORDER BY NOTE_NO ASC'
                   cursor.execute(sql)
                   rows = cursor.fetchall()
                   for row in rows:
                       data = []
                       for index in range(len(cursor.description)):
                           data.append(row[index])
                       result.append(data)
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   from App import App
                   message = 'error occured({}) 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 result
           def saveToDatabase(self, items):
               """ save given items to database """
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath, isolation_level=None)
                   # Get a cursor object
                   cursor = conn.cursor()
                   uid = self.activeDrawing.UID
                   # delete Points
                   sql = "delete from Points where Components_UID in (select UID from Components where Drawings_UID = '{}')".format(uid)
                   cursor.execute(sql)
                   # delete HMB
                   sql = "delete from HMB where Components_UID in (select UID from Components where Drawings_UID = '{}')".format(uid)
                   cursor.execute(sql)
                   # delete Components
                   sql = "delete from Components where Drawings_UID = '{}'".format(uid)
                   cursor.execute(sql)
                   for item in items:
                       sql = item.toSql()
                       if type(sql) is list:
                           for item in sql:
                               if item is not None and 2 == len(item):
                                   cursor.execute(item[0], item[1])
                       else:
                           if sql is not None and 2 == len(sql):
                               cursor.execute(sql[0], sql[1])
                   conn.commit()
               # Catch the exception
               except Exception as ex:
                   from App import App
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print(sql)
                   message = 'error occured({}) 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      set equipment data list
               @author     humkyung
               @date       2018.05.03
           '''
           def setEquipmentDataList(self, dataList):
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   for data in dataList:
                       sql = "insert or replace into EQUIPMENT_DATA_LIST(UID, ITEM_NO, SERVICE, NO_REQ, FLUID, DESC_OF_PART, OPERATION_CONDITION_TEMP, OPERATION_CONDITION_PRESS, DESIGN_CONDITION_TEMP, DESIGN_CONDITION_PRESS, MATERIAL, WEIGHT, POWER, INSULATION, PNID_NO, REV) values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
                       param = tuple(data)
                       cursor.execute(sql, param)
                   conn.commit()
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   from App import App
                   message = 'error occured({}) 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      set instrumnet data list
               @author     kyoyho
               @date       2018.08.14
           '''
           def setInstrumentDataList(self, dataList):
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   for data in dataList:
                       sql = "insert or replace into INSTRUMENT_DATA_LIST(UID, ITEM_NO, SERVICE, FLOW_RATE, PRESSURE, TEMPERATURE, TPYE, RANGE, NOR_LEVEL_MM, NOR_LEVEL_PERCENT, DEL_PRESS, SHUT_OFF, LOCATION, PNID_NO, REV) values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
                       param = tuple(data)
                       cursor.execute(sql, param)
                   conn.commit()
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   from App import App
                   message = 'error occured({}) 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      set Note data list
               @author     kyoyho
               @date       2018.10.10
           '''
           def setNoteDataList(self, dataList):
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   for data in dataList:
                       sql = "insert or replace into NOTE_DATA_LIST(UID, NOTE_NO, DESCRIPTION, PNID_NO) values(?, ?, ?, ?)"
                       param = tuple(data)
                       cursor.execute(sql, param)
                   conn.commit()
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   from App import App
                   message = 'error occured({}) 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      exists drawing
               @author     yeonjin
               @date       2019.07.03
           """
           def exists_drawing(self, drawingName):
               rows = None
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = "select name from Drawings where upper(name) = '" + drawingName.upper() + "'"
                   cursor.execute(sql)
                   rows = cursor.fetchall()
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
                   if rows is not None and len(rows) > 0:
                       return True
                   else:
                       return False
           def getDrawings(self):
               """
               @brief      get drawings
               @author     humkyung
               @date       2018.11.03
               """
               res = []
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = 'select UID,[NAME],[DATETIME] from Drawings'
                   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:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   from App import App
                   message = 'error occured({}) 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
           '''
               @brief      update drawings
               @author     yeonjin
               @date       2019.08.07
           '''
           def updateDrawing(self, drawing):
               import uuid
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = """update Drawings
                               set Name = ?
                                 , DateTime = ?
                             where uid = ?"""
                   param = (drawing[0][1], drawing[0][2], drawing[0][0])
                   cursor.execute(sql, param)
                   conn.commit()
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   from App import App
                   message = 'error occured({}) 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      save drawings
               @author     humkyung
               @date       2018.11.03
           '''
           def saveDrawing(self, drawing):
               import uuid
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = 'insert or replace into Drawings(UID, [NAME], [DATETIME]) values(?, ?, ?)'
                   param = (drawing[0][0], drawing[0][1], drawing[0][2])
                   cursor.execute(sql, param)
                   sql = "select Table_Name, Column_Name, Units_UID from DrawingsUnits where drawings_UID = '00000000-0000-0000-0000-000000000000'"
                   cursor.execute(sql)
                   rows = cursor.fetchall()
                   for row in rows:
                       sql = """insert or replace into DrawingsUnits
+                                  (
                                       UID
                                       , Drawings_UID
                                       , Table_Name
                                       , Column_Name
                                       , Units_UID
+                                   )
                                    values
+                                   (
+                                      ?
                                       , ?
                                       , ?
                                       , ?
                                       , ?
                                    )"""
                       param = (str(uuid.uuid4()), drawing[0][0], row[0], row[1], row[2])
                       cursor.execute(sql, param)
                   conn.commit()
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   from App import App
                   message = 'error occured({}) 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 IsOriginDetect ComboBox Items
           '''
           def getIsOriginDetectComboBoxItems(self):
               return [("원본 도면", 0), ("텍스트 제거 도면", 1)]
           '''
               @brief  get IsOriginDetect ComboBox Items
           '''
           def getOcrOptionComboBoxItems(self):
               return [("OCR 미적용", 0), ("일반 심볼", 1), ("Instrument 계통", 2)]
           '''
               @brief      Return Symbol Category Items
               @author     yeonjin
               @date       19.07.11
           '''
           def getSymbolCategoryList(self):
               SymbolCategoryList = []
               try:
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   cursor = conn.cursor()
                   sql = 'SELECT DISTINCT CATEGORY FROM SymbolType ORDER BY type ASC'
                   try:
                       cursor.execute(sql)
                       rows = cursor.fetchall()
                       for row in rows:
                           SymbolCategoryList.append((row[0])) # category
                   except Exception as ex:
                       from App import App
                       message = 'error occured({}) 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:
                   conn.close()
               return SymbolCategoryList
           def getComponentByComponentUID(self, uid):
               ComponentList = []
               try:
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   cursor = conn.cursor()
                   sql = """select c.uid
                                 , c.Name
                                 , c.Symbols_UID
                                 , t.Category
                                 , t.type
                                 , s.Name
                                 , s.OriginalPoint
                                 , c.X
                                 , c.Y
                                 , c.Rotation
                                 , c.Scale
                                 , p.uid
                                 , p.[Index]
                                 , p.x
                                 , p.y
                                 , p.ConnectedItem_UID
                              from points p
                              left join components c
                                on p.components_uid = c.uid
                              left join symbols s
                                on c.Symbols_UID = s.UID
                              left join SymbolType t
                                on s.symboltype_uid = t.uid
                             where c.uid = ?
                             order by p.[Index]"""
                   param = (uid,)
                   try:
                       cursor.execute(sql, param)
                       rows = cursor.fetchall()
                       for row in rows:
                           data = []
                           for index in range(len(cursor.description)):
                               data.append(row[index])
                           ComponentList.append(data) # Components_UID
                   except Exception as ex:
                       from App import App
                       message = 'error occured({}) 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:
                   conn.close()
               return ComponentList
           '''
               @brief      Return Components By DrawingUID
               @author     yeonjin
               @date       19.07.29
           '''
           def getComponentListByDrawingUID(self, uid):
               ComponentList = []
               try:
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   cursor = conn.cursor()
                   sql = 'select UID from Components where Drawings_UID = ? order by x desc'
                   try:
                       param = (uid, )
                       cursor.execute(sql, param)
                       rows = cursor.fetchall()
                       for row in rows:
                           ComponentList.append((row[0])) # Components_UID
                   except Exception as ex:
                       from App import App
                       message = 'error occured({}) 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:
                   conn.close()
               return ComponentList
           '''
               @brief      Return Symbol Type Items By Category
               @author     yeonjin
               @date       19.07.11
           '''
           def getSymbolTypeListByCategory(self, category):
               symbolTypeList = []
               try:
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   cursor = conn.cursor()
                   sql = 'SELECT UID, Category, Type FROM SymbolType WHERE Category = "' + category + '"'
                   try:
                       cursor.execute(sql)
                       rows = cursor.fetchall()
                       for row in rows:
                           symbolTypeList.append((row[0], row[1], row[2])) # UID, Category, Type
                   except Exception as ex:
                       from App import App
                       message = 'error occured({}) 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:
                   conn.close()
               return symbolTypeList
           def getUnitsByDrawingName(self, drawingName):
               unitsList = []
               try:
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   cursor = conn.cursor()
                   sql = """select ifnull(d.display_name, u.column_name)
                                 , u.UNIT
                              from units u
                              left join displayNames d
                                on u.TABLE_NAME = d.TABLE_NAME and u.COLUMN_NAME = d.COLUMN_NAME
                             where u.uid in (
                                               select distinct du.units_uid
                                                 from drawings d
                                                inner join drawingsunits du
                                                   on d.uid = du.drawings_uid
                                                where d.name = ?
+                                           )
                               and u.table_name = 'HMB'"""
                   param = (drawingName, )
                   try:
                       cursor.execute(sql, param)
                       rows = cursor.fetchall()
                       for row in rows:
                           unitsList.append((row[0], row[1]))
                   except Exception as ex:
                       from App import App
                       message = 'error occured({}) 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:
                   conn.close()
               return unitsList
           def getColumnDisplayNames(self, uid, table):
               columnDisplayNameList = []
               try:
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   cursor = conn.cursor()
                   sql = """SELECT dn.DISPLAY_NAME
                                 , u.UNIT
                              FROM DisplayNames dn
                              left join drawingsUnits du
                                on dn.TABLE_NAME = du.Table_Name and dn.COLUMN_NAME = du.Column_Name
                              left join Units u
                                on du.Units_UID = u.UID
                             where du.Drawings_UID = ?
                               and dn.Table_Name = ?
                             order by dn.[Order]"""
                   try:
                       param = (uid, table,)
                       cursor.execute(sql, param)
                       rows = cursor.fetchall()
                       for row in rows:
                           columnDisplayNameList.append((row[0], row[1])) # Display_Name
                   except Exception as ex:
                       from App import App
                       message = 'error occured({}) 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:
                   conn.close()
               return columnDisplayNameList
           '''
               @brief      Return Symbol Type Items
               @author     Jeongwoo
               @date       18.04.20
               @history    18.05.08    Jeongwoo type index changed
           '''
           def getSymbolTypeList(self):
               symbolTypeList = []
               try:
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   cursor = conn.cursor()
                   sql = 'SELECT * FROM SymbolType ORDER BY type ASC'
                   try:
                       cursor.execute(sql)
                       rows = cursor.fetchall()
                       for row in rows:
                           symbolTypeList.append((row[0], row[1], row[2])) # UID, category, type
                   except Exception as ex:
                       from App import App
                       message = 'error occured({}) 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:
                   conn.close()
               return symbolTypeList
           '''
               @brief      Get Symbol Category by Symbol Type
               @author     Jeongwoo
               @date       2018.05.09
           '''
           def getSymbolCategoryByType(self, type):
               category = None
               try:
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   cursor = conn.cursor()
                   sql = 'SELECT Category FROM SymbolType WHERE type = "' + type + '"'
                   cursor.execute(sql)
                   rows = cursor.fetchall()
                   if rows is not None and len(rows) > 0:
                       category = rows[0][0]
               except Exception as ex:
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   conn.close()
               return category
           '''
               @brief      Check Symbol Type is included in 'Equipment' Category
               @author     Jeongwoo
               @date       2018.05.09
           '''
           def isEquipmentType(self, type):
               category = self.getSymbolCategoryByType(type)
               return (category is not None and category == 'Equipment')
           '''
               @brief      Return Symbol Type Items with "None"
               @author     Jeongwoo
               @date       18.04.06
               @history    Seperate SymbolTypeList and "None"
           '''
           def getSymbolTypeComboBoxItems(self):
               symbolTypeList = self.getSymbolTypeList()
               symbolTypeList.insert(0, ('None', 'None', 'None'))
               return symbolTypeList
           '''
               @brief  get Base Symbol ComboBox Items
           '''
           def getBaseSymbolComboBoxItems(self, type = None):
               bsymbolNameList = self.getSymbolNameListByType(type)
               bsymbolNameList.sort()
               bsymbolNameList.insert(0, "None")
               return bsymbolNameList
           '''
               @brief  get Additional Symbol ComboBox Items
           '''
           def getAdditionalSymbolComboBoxItems(self):
               asymbolNameList = self.getSymbolNameList()
               asymbolNameList.sort()
               asymbolNameList.insert(0, "None")
               return asymbolNameList
           '''
               @brief  get Additional Symbol's default direction ComboBox Items
           '''
           def getDefaultSymbolDirectionComboBoxItems(self):
               return [("UP", 0), ("DOWN", 2), ("LEFT", 3), ("RIGHT", 1)]
           '''
               @brief  getter of activeDrawing
               @author humkyung
               @date   2018.07.07
           '''
           @property
           def activeDrawing(self):
               return self._activeDrawing
           '''
               @brief  setter of activeDrawing
               @author humkyung
               @date   2018.07.07
           '''
           @activeDrawing.setter
           def activeDrawing(self, value):
               self._activeDrawing = value
           def getColNames(self, table):
               """
               return column names of given table and attribute names if tabe is VALVE_DATA_LIST or EQUIPMET_DATA_LIST
               """
               res = None
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   cursor = conn.execute('select * from {}'.format(table))
                   res = [col_name[0] for col_name in cursor.description]
                   if table == 'EQUIPMET_DATA_LIST' or table == 'VALVE_DATA_LIST':
                       sql = 'select distinct c.Attribute from {} a left join Attributes b on a.uid=b.Components_UID ' \
                                                                   'left join SymbolAttribute c on b.SymbolAttribute_UID=c.UID where c.Attribute is not NULL'.format(table)
                       cursor = conn.execute(sql)
                       rows = cursor.fetchall()
                       for row in rows:
                           res.append(row[0])
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
               return res
           def add_column_into_table(self, table, columnName):
               '''
                   @brief  add column into table
                   @author euisung
                   @date   2019.03.13
               '''
               err = False
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = "alter table {} add {}".format(table, columnName)
                   cursor.execute(sql)
                   conn.commit()
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   err = True
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
                   return (True if not err else False)
           def edit_column_Name_in_table(self, table, columnName, newColName):
               '''
                   @brief  edit column into table
                   @author euisung
                   @date   2019.03.13
               '''
               err = False
               colNames = AppDocData.instance().getColNames(table)
               for index in range(len(colNames)):
                   if colNames[index] == columnName:
                       colNames[index] = newColName
                       break
               try:
                   # Creates or opens a file called mydb with a SQLite3 DB
                   dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)
                   conn = sqlite3.connect(dbPath)
                   # Get a cursor object
                   cursor = conn.cursor()
                   sql = "ALTER TABLE {} RENAME TO {}".format(table, table + '_orig')
                   cursor.execute(sql)
                   value = []
                   for colName in colNames:
                       value.append(colName + ' TEXT')
                   sql = "CREATE TABLE {}({}, CONSTRAINT '{}_PK' PRIMARY KEY('UID'))".format(table, ','.join(value), table)
                   cursor.execute(sql)
                   sql = "INSERT INTO {} SELECT * FROM {}".format(table, table + '_orig')
                   cursor.execute(sql)
                   sql = "DROP TABLE {}".format(table + '_orig')
                   cursor.execute(sql)
                   conn.commit()
               # Catch the exception
               except Exception as ex:
                   # Roll back any change if something goes wrong
                   conn.rollback()
                   err = True
                   print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
               finally:
                   # Close the db connection
                   conn.close()
                   return (True if not err else False)
           '''
               @brief  getter of OCRData
               @author humkyung
               @date   2018.11.19
           '''
           @property
           def OCRData(self):
               if self._OCRData is None:
                   configs = self.getConfigs('Text Recognition', 'OCR Data')
                   self._OCRData = configs[0].value if 1 == len(configs) else 'eng'
               return self._OCRData
           '''
               @brief  setter of OCRData
               @author humkyung
               @date   2018.11.19
           '''
           @OCRData.setter
           def OCRData(self, value):
               self._OCRData = value

프로젝트

일반

사용자정보

HYTOS

hytos / HYTOS / HYTOS / AppDocData.py @ 2ab99cff