major preview refinement, and login flow fixes

Author: raluaces

Django Files/Django_FilesApp.swift

@@ -48,6 +48,9 @@ struct Django_FilesApp: App {
     @State private var hasExistingSessions = false
     @State private var isLoading = true
     @State private var selectedTab: TabViewWindow.Tab = .files
+    @State private var showingServerConfirmation = false
+    @State private var pendingAuthURL: URL? = nil
+    @State private var pendingAuthSignature: String? = nil
 
     init() {
         // print("📱 Setting up WebSocketToastObserver")
@@ -62,18 +65,40 @@ struct Django_FilesApp: App {
                         .onAppear {
                             checkForExistingSessions()
                         }
-                } else if hasExistingSessions {
-                    TabViewWindow(sessionManager: sessionManager, selectedTab: $selectedTab)
-                } else {
+                } else if !hasExistingSessions {
                     SessionEditor(onBoarding: true, session: nil, onSessionCreated: { newSession in
                         sessionManager.selectedSession = newSession
                         hasExistingSessions = true
                     })
+                } else if sessionManager.selectedSession == nil {
+                    NavigationStack {
+                        ServerSelector(selectedSession: $sessionManager.selectedSession)
+                            .navigationTitle("Select Server")
+                    }
+                } else {
+                    TabViewWindow(sessionManager: sessionManager, selectedTab: $selectedTab)
                 }
             }
             .onOpenURL { url in
                 handleDeepLink(url)
             }
+            .sheet(isPresented: $showingServerConfirmation) {
+                ServerConfirmationView(
+                    serverURL: $pendingAuthURL,
+                    signature: $pendingAuthSignature,
+                    onConfirm: { setAsDefault in
+                        Task {
+                            await handleServerConfirmation(confirmed: true, setAsDefault: setAsDefault)
+                        }
+                    },
+                    onCancel: {
+                        Task {
+                            await handleServerConfirmation(confirmed: false, setAsDefault: false)
+                        }
+                    },
+                    context: sharedModelContainer.mainContext
+                )
+            }
         }
         .modelContainer(sharedModelContainer)
 #if os(macOS)
@@ -97,7 +122,7 @@ struct Django_FilesApp: App {
         case "authorize":
             deepLinkAuth(components)
         case "serverlist":
-            selectedTab = .serverList
+            selectedTab = .settings
         case "filelist":
             handleFileListDeepLink(components)
         default:
@@ -149,40 +174,111 @@ struct Django_FilesApp: App {
             do {
                 let existingSessions = try context.fetch(descriptor)
                 if let existingSession = existingSessions.first(where: { $0.url == serverURL.absoluteString }) {
-                    // If session exists, update it on the main thread
+                    // If session exists, just select it and update UI
                     await MainActor.run {
                         sessionManager.selectedSession = existingSession
                         hasExistingSessions = true
+                        ToastManager.shared.showToast(message: "Connected to existing server \(existingSession.url)")
                     }
                     return
                 }
 
-                // If no existing session, create and authenticate a new one
-                if let newSession = await sessionManager.createAndAuthenticateSession(
-                    url: serverURL,
-                    signature: signature,
-                    context: context
-                ) {
-                    // Update the UI on the main thread
-                    await MainActor.run {
-                        sessionManager.selectedSession = newSession
-                        hasExistingSessions = true
-                        ToastManager.shared.showToast(message: "Successfully logged into \(newSession.url)")
-                    }
+                // No existing session, show confirmation dialog
+                await MainActor.run {
+                    pendingAuthURL = serverURL
+                    pendingAuthSignature = signature
+                    showingServerConfirmation = true
                 }
             } catch {
                 print("Error checking for existing sessions: \(error)")
             }
         }
     }
 
+    private func handleServerConfirmation(confirmed: Bool, setAsDefault: Bool) async {
+        guard let serverURL = pendingAuthURL,
+              let signature = pendingAuthSignature else {
+            return
+        }
+
+        // If user cancelled, just clear the pending data and return
+        if !confirmed {
+            pendingAuthURL = nil
+            pendingAuthSignature = nil
+            return
+        }
+
+        // Create and authenticate the new session
+        let context = sharedModelContainer.mainContext
+        let descriptor = FetchDescriptor<DjangoFilesSession>()
+        
+        do {
+            let existingSessions = try context.fetch(descriptor)
+            
+            // If no existing session, create and authenticate a new one
+            if let newSession = await sessionManager.createAndAuthenticateSession(
+                url: serverURL,
+                signature: signature,
+                context: context
+            ) {
+                // Update the UI on the main thread
+                await MainActor.run {
+                    if setAsDefault {
+                        // Reset all other sessions to not be default
+                        for session in existingSessions {
+                            session.defaultSession = false
+                        }
+                        newSession.defaultSession = true
+                    }
+                    sessionManager.selectedSession = newSession
+                    hasExistingSessions = true
+                    selectedTab = .files
+                    ToastManager.shared.showToast(message: "Successfully logged into \(newSession.url)")
+                }
+            }
+        } catch {
+            ToastManager.shared.showToast(message: "Problem signing into server \(error)")
+            print("Error creating new session: \(error)")
+        }
+        
+        // Clear pending auth data
+        pendingAuthURL = nil
+        pendingAuthSignature = nil
+    }
+    
+    private func checkDefaultServer() {
+        let context = sharedModelContainer.mainContext
+        let descriptor = FetchDescriptor<DjangoFilesSession>()
+        
+        Task {
+            do {
+                let sessions = try context.fetch(descriptor)
+                await MainActor.run {
+                    if sessionManager.selectedSession == nil {
+                        if let defaultSession = sessions.first(where: { $0.defaultSession }) {
+                            sessionManager.selectedSession = defaultSession
+                            selectedTab = .files
+                        } else {
+                            selectedTab = .settings
+                        }
+                    }
+                }
+            } catch {
+                print("Error checking for default server: \(error)")
+            }
+        }
+    }
+    
     private func checkForExistingSessions() {
         let context = sharedModelContainer.mainContext
         let descriptor = FetchDescriptor<DjangoFilesSession>()
 
         do {
             let sessionsCount = try context.fetchCount(descriptor)
             hasExistingSessions = sessionsCount > 0
+            if hasExistingSessions {
+                checkDefaultServer()
+            }
             isLoading = false  // Set loading to false after check completes
         } catch {
             print("Error checking for existing sessions: \(error)")

Django Files/Views/Preview.swift

@@ -79,15 +79,87 @@ struct ContentPreview: View {
     // Text Preview
     private var textPreview: some View {
         ScrollView {
-            if let content = content, let text = String(data: content, encoding: .utf8) {
-                CodeText(text)
-                    .padding()
-            } else {
-                Text("Unable to decode text content")
-                    .foregroundColor(.red)
+            ZStack {
+                if let content = content, let text = String(data: content, encoding: .utf8) {
+                    CodeText(text)
+                        .highlightLanguage(determineLanguage(from: mimeType, fileName: fileURL.lastPathComponent))
+                        .padding()
+                } else {
+                    Text("Unable to decode text content")
+                        .foregroundColor(.red)
+                }
+            }
+            .padding(.top, 40)
+        }
+    }
+
+    // Helper function to determine the highlight language based on file type
+    private func determineLanguage(from mimeType: String, fileName: String) -> HighlightLanguage {
+        let fileExtension = (fileName as NSString).pathExtension.lowercased()
+        
+        switch fileExtension {
+        case "swift":
+            return .swift
+        case "py", "python":
+            return .python
+        case "js", "javascript":
+            return .javaScript
+        case "java":
+            return .java
+        case "cpp", "c", "h", "hpp":
+            return .cPlusPlus
+        case "html":
+            return .html
+        case "css":
+            return .css
+        case "json":
+            return .json
+        case "md", "markdown":
+            return .markdown
+        case "sh", "bash":
+            return .bash
+        case "rb", "ruby":
+            return .ruby
+        case "go":
+            return .go
+        case "rs":
+            return .rust
+        case "php":
+            return .php
+        case "sql":
+            return .sql
+        case "ts", "typescript":
+            return .typeScript
+        case "yaml", "yml":
+            return .yaml
+        default:
+            // For plain text or unknown types
+            if mimeType == "text/plain" {
+                return .plaintext
+            }
+            // Try to determine from mime type if extension didn't match
+            let mimeSubtype = mimeType.split(separator: "/").last?.lowercased() ?? ""
+            switch mimeSubtype {
+            case "javascript":
+                return .javaScript
+            case "python":
+                return .python
+            case "java":
+                return .java
+            case "html":
+                return .html
+            case "css":
+                return .css
+            case "json":
+                return .json
+            case "markdown":
+                return .markdown
+            case "xml":
+                return .html
+            default:
+                return .plaintext
             }
         }
-        .padding(.top, 35)
     }
 
     // Image Preview
@@ -838,20 +910,21 @@ struct FilePreviewView: View {
                             }
                             .background(.ultraThinMaterial)
                             .frame(width: 32, height: 32)
-                            .cornerRadius(8)
+                            .cornerRadius(16)
                             .padding(.leading, 15)
                             Spacer()
                             Text(file.name)
                                 .padding(5)
                                 .font(.headline)
                                 .lineLimit(1)
-                                .shadow(color: .black, radius: 3)
+                                .foregroundColor(file.mime.starts(with: "text") ? .primary : .white)
+                                .shadow(color: .black, radius: file.mime.starts(with: "text") ? 0 : 3)
                             Spacer()
                             Menu {
                                 fileContextMenu(for: file, isPreviewing: true, isPrivate: file.private, expirationText: $expirationText, passwordText: $passwordText, fileNameText: $fileNameText)
                                     .padding()
                             } label: {
-                                Image(systemName: "ellipsis.circle")
+                                Image(systemName: "ellipsis")
                                     .font(.system(size: 20))
                                     .padding()
                             }
@@ -861,6 +934,15 @@ struct FilePreviewView: View {
                             .cornerRadius(16)
                             .padding(.trailing, 10)
                         }
+                        .padding(.vertical, 8)
+                        .frame(maxWidth: .infinity)
+                        .background {
+                            if file.mime.starts(with: "text") {
+                                Rectangle()
+                                    .fill(.ultraThinMaterial)
+                                    .ignoresSafeArea()
+                            }
+                        }
                         Spacer()
                         HStack {
                             Spacer()