refactor: DatabaseChecker

ui/startup/databaseChecker.py

@@ -1,13 +1,18 @@
+import logging
 import traceback
+from typing import Literal, Optional, Union
 
 from arcaea_offline.database import Database
-from PySide6.QtCore import QDir, QFile, Qt, QTimer, Slot
+from PySide6.QtCore import QCoreApplication, QDir, QFileInfo, Qt, QTimer, QUrl, Slot
 from PySide6.QtWidgets import QDialog, QMessageBox
 
+from ui.extends.shared.database import create_engine
 from ui.extends.shared.settings import Settings
 
 from .databaseChecker_ui import Ui_DatabaseChecker
 
+logger = logging.getLogger(__name__)
+
 
 class DatabaseChecker(Ui_DatabaseChecker, QDialog):
     def __init__(self, parent=None):
@@ -16,67 +21,98 @@ class DatabaseChecker(Ui_DatabaseChecker, QDialog):
         self.setWindowFlag(Qt.WindowType.WindowMinimizeButtonHint, False)
         self.setWindowFlag(Qt.WindowType.WindowMaximizeButtonHint, False)
         self.setWindowFlag(Qt.WindowType.WindowCloseButtonHint, True)
-        self.dbFileSelector.setMode(self.dbFileSelector.getExistingDirectory)
-        self.dbFileSelector.filesSelected.connect(self.fileSelected)
+        self.dbDirSelector.setMode(self.dbDirSelector.getExistingDirectory)
 
+        self.confirmDbByExistingSettings = False
         self.settings = Settings(self)
-        dbDir = self.settings.value("Default/DbDir", None, str)
-        if dbDir and QFile(QDir(dbDir).filePath(Database.dbFilename)).exists():
-            self.dbFileSelector.selectFile(dbDir)
-            result = self.checkDbVersion()
-            if result:
-                QTimer.singleShot(50, self.accept)
+        dbUrlString = self.settings.databaseUrl()
+
+        if dbUrlString:
+            dbFileUrl = QUrl(dbUrlString.replace("sqlite://", "file://"))
+            dbFileInfo = QFileInfo(dbFileUrl.toLocalFile())
+            if dbFileInfo.exists():
+                self.dbDirSelector.selectFile(dbFileInfo.path())
+                self.dbFilenameLineEdit.setText(dbFileInfo.fileName())
+                self.confirmDbByExistingSettings = True
+                self.confirmDbPathButton.click()
+            else:
+                self.dbDirSelector.selectFile(QDir.currentPath())
+                self.dbFilenameLineEdit.setText("arcaea_offline.db")
         else:
-            self.dbFileSelector.selectFile(QDir.currentPath())
+            self.dbDirSelector.selectFile(QDir.currentPath())
+            self.dbFilenameLineEdit.setText("arcaea_offline.db")
 
-    def fileSelected(self):
-        self.checkDbVersion()
-
-    def checkDbVersion(self) -> str | None:
-        dbQDir = QDir(self.dbFileSelector.selectedFiles()[0])
-        dbDir = dbQDir.absolutePath()
-
-        dbDir = self.dbFileSelector.selectedFiles()[0]
-        dbQFile = QFile(QDir(dbDir).filePath(Database.dbFilename))
-        if not dbQFile.exists():
-            result = QMessageBox.question(self, "Database", "Create database file now?")
-            if result != QMessageBox.StandardButton.Yes:
-                return
-            dbQFile.open(QFile.OpenModeFlag.WriteOnly)
-            dbQFile.close()
-
-        Database.dbDir = dbDir
-
-        try:
-            with Database().conn as conn:
-                version = conn.execute(
-                    "SELECT value FROM properties WHERE key = 'db_version'"
-                ).fetchone()[0]
-                self.dbVersionLabel.setText(version)
-                self.continueButton.setEnabled(True)
+    def updateLabels(
+        self,
+        version: Union[Optional[int], Literal["reset"]],
+        init_status: Union[Optional[bool], Literal["reset"]],
+    ):
+        if version is not None:
+            self.dbVersionLabel.setText(str(version))
+        elif version == "reset":
+            self.dbVersionLabel.setText("-")
 
+        if init_status is not None:
+            if init_status:
                 self.dbCheckConnLabel.setText('<font color="green">OK</font>')
-                self.settings.setValue("Default/DbDir", dbDir)
-            return version
-        except Exception as e:
-            QMessageBox.critical(
-                self, "Database Error", "\n".join(traceback.format_exception(e))
-            )
-            self.dbInitButton.setEnabled(True)
+                self.continueButton.setEnabled(True)
+            else:
+                self.dbCheckConnLabel.setText('<font color="red">Error</font>')
+                self.continueButton.setEnabled(False)
+        elif init_status == "reset":
+            self.dbCheckConnLabel.setText("-")
             self.continueButton.setEnabled(False)
-            self.dbCheckConnLabel.setText('<font color="red">Error</font>')
-            return False
 
     @Slot()
-    def on_dbInitButton_clicked(self):
-        try:
-            Database().init()
-        except Exception as e:
-            QMessageBox.critical(
-                self, "Database Error", "\n".join(traceback.format_exception(e))
+    def on_confirmDbPathButton_clicked(self):
+        dbPath = QDir(self.dbDirSelector.selectedFiles()[0])
+        dbFileInfo = QFileInfo(
+            QDir.cleanPath(dbPath.absoluteFilePath(self.dbFilenameLineEdit.text()))
+        )
+        dbFileUrl = QUrl.fromLocalFile(dbFileInfo.filePath())
+        # dbSqliteUrl.setScheme("sqlite")
+        dbSqliteUrl = QUrl(dbFileUrl.toString().replace("file://", "sqlite://"))
+        if not dbFileInfo.exists():
+            confirm_new_database = QMessageBox.question(
+                self,
+                None,
+                # fmt: off
+                QCoreApplication.translate("DatabaseChecker", "dialog.confirmNewDatabase"),
+                # fmt: on
             )
-        finally:
-            self.checkDbVersion()
+            if confirm_new_database == QMessageBox.StandardButton.Yes:
+                db = Database(create_engine(dbSqliteUrl))
+                db.init()
+                self.on_confirmDbPathButton_clicked()
+        else:
+            db = Database(create_engine(dbSqliteUrl))
+            if db.check_init():
+                self.updateLabels(db.version(), True)
+                if self.confirmDbByExistingSettings:
+                    QTimer.singleShot(25, self.accept)
+                else:
+                    self.settings.setDatabaseUrl(dbSqliteUrl.toString())
+            else:
+                confirm_try_init = QMessageBox.question(
+                    self,
+                    None,
+                    # fmt: off
+                    QCoreApplication.translate("DatabaseChecker", "dialog.tryInit"),
+                    # fmt: on
+                )
+                if confirm_try_init == QMessageBox.StandardButton.Yes:
+                    try:
+                        db.init(checkfirst=True)
+                    except Exception as e:
+                        logger.exception(
+                            "Error while initializing an existing database"
+                        )
+                        QMessageBox.critical(
+                            self, None, "\n".join(traceback.format_exception(e))
+                        )
+                        self.updateLabels("reset", False)
+                    finally:
+                        self.on_confirmDbPathButton_clicked()
 
     @Slot()
     def on_continueButton_clicked(self):