HYTOS

from Project import Project

    from ProjectDialog import Ui_Dialog

    '''

        @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

    DATABASE = App.NAME + '.db'

        @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

    '''

        @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

    '''

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

    '''

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

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

            conn = sqlite3.connect(prjDatabaseFilePath)

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

            conn.rollback()

            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

    def getRoughness(self):

        res = []

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

        with conn:

            try:

                conn.row_factory = sqlite3.Row

                # Get a cursor object

                cursor = conn.cursor()

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

                cursor.execute(sql)

                rows = cursor.fetchall()

                for row in rows:                

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

            # Catch the exception

            except Exception as ex:

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

        return res

    def getInsideDiameter(self, nominaldiameter_uid, schedule_uid):

        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)

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

            # Get a cursor object

            cursor = db.cursor()

            sql = """select UID

                          , Milimeter

                          , Inch 

                       from InsideDiameter

                      where NominalDiameter_UID = ?

                        and Schedule_UID = ?"""

            param = (nominaldiameter_uid, schedule_uid)

            cursor.execute(sql, param)

            rows = cursor.fetchall()

            for row in rows:                

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

        # Catch the exception

        except Exception as ex:

            # 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

    def getNominalDiameter(self):

    '''

        @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 = self.getAppDbPath()

                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

            @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 initializeDataByDrawingUID(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)            

            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 deleteDrawingByName(self, drawingName):

        """ delete given drawing """

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

        with conn:

            try:

                # Get a cursor object

                cursor = conn.cursor()

                sql = 'delete from Drawings where Name=?'

                param = (drawingName,)

                cursor.execute(sql, param)

                conn.commit()

            # Catch the exception

            except Exception as ex:

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

    '''

        @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

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

        with conn:

            cursor = conn.cursor()

            sql = """select s.UID

                            , s.Name

                            , t.Category

                            , t.Type

                            , s.OriginalPoint

                            , s.ConnectionPoint

                        from Symbols s

                        inner join SymbolType t

                            on s.SymbolType_UID = t.UID 

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

            try:

                cursor.execute(sql, (param,))

                rows = cursor.fetchall()

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

                    symbolTuple = rows[0]

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

            except Exception as ex:

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

        return ret

    def getSymbolListByUID(self, uid):

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

        ret = []

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

        with conn:

            cursor = conn.cursor()

            sql = """select s.UID

                            , s.Name

                            , t.Category

                            , t.Type

                            , s.OriginalPoint

                            , s.ConnectionPoint

                        from Symbols s

                        inner join SymbolType t

                            on s.SymbolType_UID = t.uid 

                        where s.SymbolType_UID = ?"""

            try:

                cursor.execute(sql, (uid,))

                rows = cursor.fetchall()

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

                    for row in rows:

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

                        ret.append(sym)

            except Exception as ex:

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

        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