feat: Implement authentication provider management components

- Added new templates for managing authentication providers, including forms for creating and editing providers.
- Implemented backend logic to handle retrieval, creation, and deletion of authentication providers.
- Introduced new database migrations to support the storage of authentication provider data.
- Enhanced the user interface to display available authentication providers and their statuses.
- Added routes and handlers for managing authentication provider actions in the web application.

internal/db/migrations/011_add_auth_providers.go

@@ -0,0 +1,134 @@
+package migrations
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/go-gormigrate/gormigrate/v2"
+	"gorm.io/gorm"
+)
+
+// AddAuthProviders adds tables for external authentication providers
+func AddAuthProviders() *gormigrate.Migration {
+	return &gormigrate.Migration{
+		ID: "011_add_auth_providers",
+		Migrate: func(tx *gorm.DB) error {
+			// Check if any tables exist (indicating an existing database)
+			var count int64
+			if err := tx.Raw("SELECT count(*) FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'").Scan(&count).Error; err != nil {
+				return fmt.Errorf("failed to check for existing tables: %v", err)
+			}
+
+			// If tables exist, create a backup
+			if count > 0 {
+				// Get the database path
+				sqlDB, err := tx.DB()
+				if err != nil {
+					return fmt.Errorf("failed to get underlying database: %v", err)
+				}
+
+				var seq int
+				var name, dbPath string
+				if err := sqlDB.QueryRow("PRAGMA database_list").Scan(&seq, &name, &dbPath); err != nil {
+					return fmt.Errorf("failed to get database path: %v", err)
+				}
+
+				// Get backup directory from environment variable or use default
+				backupDir := os.Getenv("BACKUP_DIR")
+				if backupDir == "" {
+					backupDir = "/app/backups" // Default Docker path
+					// Check if we're not in Docker
+					if _, err := os.Stat(backupDir); os.IsNotExist(err) {
+						backupDir = "backups" // Fallback to local directory
+					}
+				}
+
+				// Create backup directory if it doesn't exist
+				if err := os.MkdirAll(backupDir, 0755); err != nil {
+					return fmt.Errorf("failed to create backup directory: %v", err)
+				}
+
+				// Create backup file with timestamp in the backup directory
+				dbFileName := filepath.Base(dbPath)
+				backupFileName := fmt.Sprintf("%s.backup.%s", dbFileName, time.Now().Format("20060102_150405"))
+				backupFile := filepath.Join(backupDir, backupFileName)
+
+				// Read original database
+				data, err := os.ReadFile(dbPath)
+				if err != nil {
+					return fmt.Errorf("failed to read database for backup: %v", err)
+				}
+
+				// Write backup
+				if err := os.WriteFile(backupFile, data, 0644); err != nil {
+					return fmt.Errorf("failed to write database backup: %v", err)
+				}
+
+				fmt.Printf("Created database backup at %s\n", backupFile)
+			}
+
+			// Create auth_providers table
+			if err := tx.Exec(`CREATE TABLE IF NOT EXISTS auth_providers (
+				id INTEGER PRIMARY KEY AUTOINCREMENT,
+				name VARCHAR(255) NOT NULL,
+				type VARCHAR(50) NOT NULL,
+				enabled BOOLEAN DEFAULT TRUE,
+				description TEXT,
+				provider_url TEXT,
+				icon_url TEXT,
+				client_id VARCHAR(255),
+				client_secret VARCHAR(255),
+				redirect_url TEXT,
+				scopes TEXT,
+				attribute_mapping TEXT,
+				config TEXT,
+				successful_logins INTEGER DEFAULT 0,
+				last_used DATETIME,
+				created_at DATETIME,
+				updated_at DATETIME
+			)`).Error; err != nil {
+				return err
+			}
+
+			// Create external_user_identities table
+			if err := tx.Exec(`CREATE TABLE IF NOT EXISTS external_user_identities (
+				id INTEGER PRIMARY KEY AUTOINCREMENT,
+				user_id INTEGER NOT NULL,
+				provider_id INTEGER NOT NULL,
+				provider_type VARCHAR(50) NOT NULL,
+				external_id VARCHAR(255) NOT NULL,
+				email VARCHAR(255) NOT NULL,
+				username VARCHAR(255),
+				display_name VARCHAR(255),
+				groups TEXT,
+				last_login DATETIME,
+				provider_data TEXT,
+				created_at DATETIME,
+				updated_at DATETIME,
+				FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
+				FOREIGN KEY (provider_id) REFERENCES auth_providers(id) ON DELETE CASCADE
+			)`).Error; err != nil {
+				return err
+			}
+
+			// Create unique index on provider_id and external_id
+			if err := tx.Exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_external_user_identities_provider_external 
+				ON external_user_identities(provider_id, external_id)`).Error; err != nil {
+				return err
+			}
+
+			return nil
+		},
+		Rollback: func(tx *gorm.DB) error {
+			if err := tx.Exec("DROP TABLE IF EXISTS external_user_identities").Error; err != nil {
+				return err
+			}
+			if err := tx.Exec("DROP TABLE IF EXISTS auth_providers").Error; err != nil {
+				return err
+			}
+			return nil
+		},
+	}
+}

internal/db/migrations/migrations.go

@@ -21,6 +21,7 @@ func GetMigrations(db *gorm.DB) *gormigrate.Gormigrate {
 		AddUserNotifications(),        // 008
 		AddRcloneTables(),             // 009
 		AddRcloneCommandToConfig(),    // 010
+		AddAuthProviders(),            // 011
 	)
 
 	return gormigrate.New(db, gormigrate.DefaultOptions, migrations)