upload all

backend/providers/provider.go

@@ -0,0 +1,214 @@
+package providers
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sync"
+)
+
+// ProviderConfig enthält die Konfiguration eines Providers
+type ProviderConfig struct {
+	Enabled  bool                   `json:"enabled"`
+	Settings map[string]interface{} `json:"settings"`
+}
+
+// SignCSRResult enthält das Ergebnis einer CSR-Signierung
+type SignCSRResult struct {
+	CertificatePEM string `json:"certificatePEM"`
+	OrderID        string `json:"orderId,omitempty"`
+	Status         string `json:"status"`
+	Message        string `json:"message,omitempty"`
+}
+
+// Provider Interface für alle SSL Certificate Provider
+type Provider interface {
+	// GetName gibt den Namen des Providers zurück
+	GetName() string
+	// GetDisplayName gibt den Anzeigenamen zurück
+	GetDisplayName() string
+	// GetDescription gibt eine Beschreibung zurück
+	GetDescription() string
+	// ValidateConfig validiert die Konfiguration
+	ValidateConfig(settings map[string]interface{}) error
+	// TestConnection testet die Verbindung zum Provider
+	TestConnection(settings map[string]interface{}) error
+	// GetRequiredSettings gibt die erforderlichen Einstellungen zurück
+	GetRequiredSettings() []SettingField
+	// SignCSR signiert einen CSR und gibt das Zertifikat zurück
+	SignCSR(csrPEM string, settings map[string]interface{}) (*SignCSRResult, error)
+	// GetCertificate ruft ein Zertifikat anhand der Zertifikat-ID ab
+	GetCertificate(certificateID string, settings map[string]interface{}) (string, error)
+}
+
+// ProviderManager verwaltet alle Provider
+type ProviderManager struct {
+	providers map[string]Provider
+	configs   map[string]*ProviderConfig
+	configDir string
+	mu        sync.RWMutex
+}
+
+var manager *ProviderManager
+var once sync.Once
+
+// GetManager gibt die Singleton-Instanz des ProviderManagers zurück
+func GetManager() *ProviderManager {
+	once.Do(func() {
+		manager = &ProviderManager{
+			providers: make(map[string]Provider),
+			configs:   make(map[string]*ProviderConfig),
+			configDir: "./config/providers",
+		}
+		manager.loadAllConfigs()
+	})
+	return manager
+}
+
+// RegisterProvider registriert einen neuen Provider
+func (pm *ProviderManager) RegisterProvider(provider Provider) {
+	pm.mu.Lock()
+	defer pm.mu.Unlock()
+	
+	providerID := pm.getProviderID(provider.GetName())
+	pm.providers[providerID] = provider
+	
+	// Lade Konfiguration falls vorhanden
+	if pm.configs[providerID] == nil {
+		pm.configs[providerID] = &ProviderConfig{
+			Enabled:  false,
+			Settings: make(map[string]interface{}),
+		}
+	}
+}
+
+// GetProvider gibt einen Provider zurück
+func (pm *ProviderManager) GetProvider(id string) (Provider, bool) {
+	pm.mu.RLock()
+	defer pm.mu.RUnlock()
+	provider, exists := pm.providers[id]
+	return provider, exists
+}
+
+// GetAllProviders gibt alle registrierten Provider zurück
+func (pm *ProviderManager) GetAllProviders() map[string]Provider {
+	pm.mu.RLock()
+	defer pm.mu.RUnlock()
+	result := make(map[string]Provider)
+	for id, provider := range pm.providers {
+		result[id] = provider
+	}
+	return result
+}
+
+// GetProviderConfig gibt die Konfiguration eines Providers zurück
+func (pm *ProviderManager) GetProviderConfig(id string) (*ProviderConfig, error) {
+	pm.mu.RLock()
+	defer pm.mu.RUnlock()
+	
+	config, exists := pm.configs[id]
+	if !exists {
+		return &ProviderConfig{
+			Enabled:  false,
+			Settings: make(map[string]interface{}),
+		}, nil
+	}
+	return config, nil
+}
+
+// UpdateProviderConfig aktualisiert die Konfiguration eines Providers
+func (pm *ProviderManager) UpdateProviderConfig(id string, config *ProviderConfig) error {
+	pm.mu.Lock()
+	defer pm.mu.Unlock()
+	
+	provider, exists := pm.providers[id]
+	if !exists {
+		return fmt.Errorf("provider %s nicht gefunden", id)
+	}
+	
+	// Validiere Konfiguration
+	if err := provider.ValidateConfig(config.Settings); err != nil {
+		return fmt.Errorf("ungültige Konfiguration: %v", err)
+	}
+	
+	pm.configs[id] = config
+	
+	// Speichere Konfiguration in Datei
+	return pm.saveConfig(id, config)
+}
+
+// SetProviderEnabled aktiviert/deaktiviert einen Provider
+func (pm *ProviderManager) SetProviderEnabled(id string, enabled bool) error {
+	pm.mu.Lock()
+	defer pm.mu.Unlock()
+	
+	if pm.configs[id] == nil {
+		pm.configs[id] = &ProviderConfig{
+			Enabled:  enabled,
+			Settings: make(map[string]interface{}),
+		}
+	} else {
+		pm.configs[id].Enabled = enabled
+	}
+	
+	return pm.saveConfig(id, pm.configs[id])
+}
+
+// getProviderID erstellt eine ID aus dem Provider-Namen
+func (pm *ProviderManager) getProviderID(name string) string {
+	return name
+}
+
+// loadAllConfigs lädt alle Konfigurationsdateien
+func (pm *ProviderManager) loadAllConfigs() {
+	// Stelle sicher, dass das Verzeichnis existiert
+	os.MkdirAll(pm.configDir, 0755)
+	
+	// Lade alle JSON-Dateien im Konfigurationsverzeichnis
+	files, err := filepath.Glob(filepath.Join(pm.configDir, "*.json"))
+	if err != nil {
+		return
+	}
+	
+	for _, file := range files {
+		id := filepath.Base(file[:len(file)-5]) // Entferne .json
+		config, err := pm.loadConfig(id)
+		if err == nil {
+			pm.configs[id] = config
+		}
+	}
+}
+
+// loadConfig lädt eine Konfigurationsdatei
+func (pm *ProviderManager) loadConfig(id string) (*ProviderConfig, error) {
+	filePath := filepath.Join(pm.configDir, id+".json")
+	
+	data, err := os.ReadFile(filePath)
+	if err != nil {
+		return nil, err
+	}
+	
+	var config ProviderConfig
+	if err := json.Unmarshal(data, &config); err != nil {
+		return nil, err
+	}
+	
+	return &config, nil
+}
+
+// saveConfig speichert eine Konfiguration in eine Datei
+func (pm *ProviderManager) saveConfig(id string, config *ProviderConfig) error {
+	// Stelle sicher, dass das Verzeichnis existiert
+	os.MkdirAll(pm.configDir, 0755)
+	
+	filePath := filepath.Join(pm.configDir, id+".json")
+	
+	data, err := json.MarshalIndent(config, "", "  ")
+	if err != nil {
+		return err
+	}
+	
+	return os.WriteFile(filePath, data, 0644)
+}
+