working settings page (yipperz)

Author: daveberrys

main.py

@@ -1,5 +1,6 @@
 from src.front.window import startUp as s
 from src.back.system.history import History
+from src.back.system.settings import Settings
 
 import argparse
 import sys
@@ -10,6 +11,7 @@
 
 debugMode = args.debug
 History().checkHistory()
+Settings().checkFile()
 
 if __name__ == "__main__":
     s(debugMode=debugMode)

src/back/extra/settings.json

@@ -0,0 +1,31 @@
+{
+    "settings": {
+        "checkForUpdates": {
+            "name": "Check For Updates",
+            "description": "Check for updates on startup. Reccomended to be enabled!",
+            "type": "boolean",
+            "default": "true"
+        },
+
+        "history": {
+            "name": "History",
+            "description": "Always stores the sucsessful uploads in a json file.",
+            "type": "boolean",
+            "default": "true"
+        },
+
+        "minimizeToTray": {
+            "name": "Minimize To Tray",
+            "description": "Minimizes the app to the system tray instead of closing it.",
+            "type": "boolean",
+            "default": "true"
+        },
+
+        "notifyYou": {
+            "name": "Notify You",
+            "description": "Send you a notification when it's sending, when it's done and when it gives an error.",
+            "type": "boolean",
+            "default": "true"
+        }
+    }
+}

src/back/system/contact.py

@@ -1,11 +1,13 @@
 import webview
 import os
 import sys
+import json
 
 from src.back.api.sendingFile import catbox, litterbox, buzzheavier
 from src.back.api.checkForUpdate import isUpdateAvailable
 from src.back.util.notify import notify
 import src.back.util.print as print
+from src.back.system.settings import Settings
 
 class API:
     def pickFile(self):
@@ -60,4 +62,54 @@ def checkForUpdates(self):
             return isUpdateAvailable(currentVersion)
         except Exception as e:
             print.error(f"Network error: {e}")
-            return {"status": "error", "message": f"Network error: {e}"}
+            return {"status": "error", "message": f"Network error: {e}"}
+
+    def localCurrentVersion(self):
+        try:
+            if getattr(sys, 'frozen', False):
+                basePath = sys._MEIPASS
+            else:
+                basePath = os.path.abspath(".")
+
+            versionPath = os.path.join(basePath, "version.txt")
+            with open(versionPath, "r") as f:
+                currentVersion = f.read().strip()
+                return currentVersion
+        except Exception as e:
+            print.error(f"Local file error: {e}")
+            return None
+
+    def getSettings(self):
+        print.debug("API: getSettings called")
+        try:
+            settings = Settings()
+            
+            # Load the settings definitions (names, descriptions)
+            if os.path.exists(settings.defaultSettingsPath):
+                with open(settings.defaultSettingsPath, "r") as f:
+                    data = json.load(f)
+                print.success(f"Default settings loaded from: {settings.defaultSettingsPath}")
+            else:
+                print.error(f"Default settings MISSING at: {settings.defaultSettingsPath}")
+                return {"settings": {}}
+            
+            # Load the user's current saved settings
+            user_settings = {}
+            if os.path.exists(settings.settingsPath):
+                with open(settings.settingsPath, "r") as f:
+                    user_settings = json.load(f)
+                print.success(f"User settings loaded from: {settings.settingsPath}")
+            
+            # Update the definitions with the user's values
+            for key, value in data["settings"].items():
+                if key in user_settings:
+                    data["settings"][key]["default"] = str(user_settings[key]).lower()
+            
+            return data
+        except Exception as e:
+            print.error(f"Error fetching settings: {e}")
+            return {"settings": {}}
+
+    def saveSettings(self, key, value):
+        settings = Settings()
+        return settings.updateSetting(key, value)

src/back/system/history.py

@@ -21,7 +21,6 @@
 
 """
 
-
 import json
 import os
 import datetime
@@ -40,8 +39,8 @@ def checkHistory(self):
             print.success(f"History found at: {self.historyPath}")
             return True
         else:
-            print.error(f"History not found at: {self.historyPath}")
-            print.success(f"Creating history at: {self.historyPath}")
+            print.warning(f"History not found at: {self.historyPath}")
+            print.debug(f"Creating history at: {self.historyPath}")
 
             try:
                 se.checkFolder(self)
@@ -53,7 +52,7 @@ def checkHistory(self):
                 print.error(f"Error creating history: {e}")
                 return False
             except OSError as e:
-                print.fatal(f"Fatal error creating history: {e}")
+                print.fatal(f"Fatal OS error creating history: {e}")
                 return False
 
     def storeHistory(self, service, filename, link, litterboxdur):
@@ -72,5 +71,4 @@ def storeHistory(self, service, filename, link, litterboxdur):
 
             return print.success(f"History stored at: {self.historyPath}")
         except Exception as e:
-            return print.error(f"Error storing history: {e}")
-
+            return print.error(f"Error storing history: {e}")

src/back/system/settings.py

@@ -1,9 +1,12 @@
 import os
+import json
+
 from sys import platform
+
 import src.back.util.print as print
 
 appID = "dev.pages.codedave.SendYourFiles"
-configPath = ""
+
 
 class Sys:
     def getOSpath(self):
@@ -12,22 +15,129 @@ def getOSpath(self):
         elif platform == "linux":
             configPath = os.path.join(os.getenv("XDG_CONFIG_HOME"), appID)
         elif platform == "darwin":
-            configPath = os.path.join(os.getenv("HOME"), "Library", "Application Support", appID)
+            configPath = os.path.join(
+                os.getenv("HOME"), "Library", "Application Support", appID
+            )
         else:
             configPath = os.path.join(os.getenv("HOME"), ".config", appID)
         print.debug(f"Config path: {configPath}")
         return configPath
 
+
 class Settings:
+    def __init__(self):
+        self.configPath = os.path.join(Sys.getOSpath(self))
+
+        self.settingsPath = os.path.join(self.configPath, "settings.json")
+        self.defaultSettingsPath = os.path.join(os.path.dirname(__file__), "extra", "settings.json")
+        
+        if not os.path.exists(self.defaultSettingsPath):
+            # Fallback for running from root
+            self.defaultSettingsPath = os.path.abspath(os.path.join("src", "back", "extra", "settings.json"))
+
+        self.defaultSettings = {}
+        self.settings = {}
+
+        # passing through
+        self.readSet = self.ReadSettings(self.settingsPath)
+
     def checkFolder(self):
-        configPath = Sys.getOSpath(self)
-        if not os.path.exists(configPath):
+        if os.path.exists(self.configPath):
+            print.success(f"Config path found at: {self.configPath}")
+            return True
+        else:
+            print.warning(f"Config path not found at: {self.configPath}")
+            print.debug(f"Creating config path at: {self.configPath}")
+            
             try:
-                os.makedirs(configPath)
-                print.success(f"Created config path: {configPath}")
+                os.makedirs(self.configPath)
+                print.success(f"Config path created at: {self.configPath}")
+                return True
             except Exception as e:
                 print.error(f"Error creating config path: {e}")
+                return False
             except OSError as e:
-                print.fatal(f"Fatal error creating config path: {e}")
+                print.fatal(f"Fatal OS error creating config path: {e}")
+                return False
+
+    def checkFile(self):
+        if os.path.exists(self.settingsPath):
+            print.success(f"Settings found at: {self.settingsPath}")
+            return True
         else:
-            print.debug(f"Config path already exists: {configPath}")
+            print.warning(f"Settings not found at: {self.settingsPath}")
+            print.debug(f"Creating settings file at: {self.settingsPath}")
+
+            try:
+                with open(self.settingsPath, "w") as f:
+                    with open(self.defaultSettingsPath, "r") as f2:
+                        data = json.load(f2)
+                        newSettings = {}
+                        for key, value in data["settings"].items():
+                            val = value["default"]
+                            if value.get("type") == "boolean":
+                                if str(val).lower() == "true":
+                                    val = True
+                                elif str(val).lower() == "false":
+                                    val = False
+                            newSettings[key] = val
+                        json.dump(newSettings, f, indent=4)
+                print.success(f"Settings created at: {self.settingsPath}")
+                return True
+            except Exception as e:
+                print.error(f"Error creating settings: {e}")
+                return False
+            except OSError as e:
+                print.fatal(f"Fatal OS error creating settings: {e}")
+                return False
+
+    def updateSetting(self, key, value):
+        try:
+            data = {}
+            if os.path.exists(self.settingsPath):
+                with open(self.settingsPath, "r") as f:
+                    data = json.load(f)
+            
+            data[key] = value
+
+            with open(self.settingsPath, "w") as f:
+                json.dump(data, f, indent=4)
+            return True
+        except Exception as e:
+            print.error(f"Error updating setting: {e}")
+            return False
+    
+    class ReadSettings:
+        def __init__(self, path):
+            self.settingPath = path
+
+        def _checkForUpdates(self):
+            try:
+                with open(self.settingPath, "r") as f:
+                    return json.load(f).get("checkForUpdates", True)
+            except Exception:
+                pass
+
+        def _history(self):
+            try:
+                with open(self.settingPath, "r") as f:
+                    return json.load(f).get("history", True)
+            except Exception:
+                pass
+            return True
+
+        def _minimizeToTray(self):
+            try:
+                with open(self.settingPath, "r") as f:
+                    return json.load(f).get("minimizeToTray", True)
+            except Exception:
+                pass
+            return True
+        
+        def _notifyYou(self):
+            try:
+                with open(self.settingPath, "r") as f:
+                    return json.load(f).get("notifyYou", True)
+            except Exception:
+                pass
+            return True

src/front/main/css/cacaStyle.css

@@ -96,4 +96,28 @@ body {
     user-select: text;
     -webkit-user-select: text;
     cursor: text;
-}
+}
+
+select {
+    background-color: var(--frameColor);
+    color: var(--textColor);
+
+    border: none;
+    padding: 5px 10px;
+    border-radius: 5px;
+    width: 100%;
+    margin-top: 10px;
+
+    outline: none;
+    cursor: pointer;
+
+    font-family: inherit;
+}
+
+option {
+    border-radius: 5px;
+    border: none;
+
+    background-color: var(--frameColor);
+    color: var(--textColor);
+}