100 lines
3.1 KiB
Go
100 lines
3.1 KiB
Go
package db
|
|
|
|
import (
|
|
"database/sql"
|
|
"fmt"
|
|
|
|
"github.com/timetracker/backend/internal/domain/persistence"
|
|
"github.com/timetracker/backend/internal/infrastructure/persistence/db/ds"
|
|
"gorm.io/driver/postgres"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
// DatabaseConfig enthält die Konfigurationsinformationen für die Datenbankverbindung
|
|
type DatabaseConfig struct {
|
|
Host string
|
|
Port int
|
|
User string
|
|
Password string
|
|
DBName string
|
|
SSLMode string
|
|
}
|
|
|
|
// DatasourceContainer enthält alle Datasource-Instanzen
|
|
type DatasourceContainer struct {
|
|
ActivityDatasource persistence.ActivityDatasource
|
|
CompanyDatasource persistence.CompanyDatasource
|
|
CustomerDatasource persistence.CustomerDatasource
|
|
ProjectDatasource persistence.ProjectDatasource
|
|
TimeEntryDatasource persistence.TimeEntryDatasource
|
|
UserDatasource persistence.UserDatasource
|
|
}
|
|
|
|
// NewDatasourceContainer erstellt und initialisiert alle Datasource-Instanzen
|
|
func NewDatasourceContainer(config DatabaseConfig) (*DatasourceContainer, error) {
|
|
// Erstelle DSN (Data Source Name) für die Datenbankverbindung
|
|
dsn := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=%s",
|
|
config.Host, config.Port, config.User, config.Password, config.DBName, config.SSLMode)
|
|
|
|
// Erstelle SQL-Datenbankverbindung
|
|
sqlDB, err := sql.Open("pgx", dsn)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("fehler beim Öffnen der SQL-Verbindung: %w", err)
|
|
}
|
|
|
|
// Konfiguriere Verbindungspool
|
|
sqlDB.SetMaxIdleConns(10)
|
|
sqlDB.SetMaxOpenConns(100)
|
|
|
|
// Initialisiere GORM mit der SQL-Verbindung
|
|
gormDB, err := gorm.Open(postgres.New(postgres.Config{
|
|
Conn: sqlDB,
|
|
}), &gorm.Config{})
|
|
if err != nil {
|
|
return nil, fmt.Errorf("fehler beim Initialisieren von GORM: %w", err)
|
|
}
|
|
|
|
// Erstelle alle Datasource-Instanzen
|
|
return &DatasourceContainer{
|
|
ActivityDatasource: ds.NewActivityDatasource(gormDB),
|
|
CompanyDatasource: ds.NewCompanyDatasource(gormDB),
|
|
CustomerDatasource: ds.NewCustomerDatasource(gormDB),
|
|
ProjectDatasource: ds.NewProjectDatasource(gormDB),
|
|
TimeEntryDatasource: ds.NewTimeEntryDatasource(gormDB),
|
|
UserDatasource: ds.NewUserDatasource(gormDB),
|
|
}, nil
|
|
}
|
|
|
|
// Close schließt die Datenbankverbindung
|
|
func (r *DatasourceContainer) Close() error {
|
|
db, err := r.getGormDB()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
sqlDB, err := db.DB()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return sqlDB.Close()
|
|
}
|
|
|
|
// Helper-Methode, um die GORM-DB aus einem der Repositories zu extrahieren
|
|
func (r *DatasourceContainer) getGormDB() (*gorm.DB, error) {
|
|
// Wir nehmen an, dass alle Repositories das gleiche DB-Handle verwenden
|
|
// Deshalb können wir einfach eines der Repositories nehmen
|
|
// Dies funktioniert nur, wenn wir Zugriff auf die interne DB haben oder eine Methode hinzufügen
|
|
// Hier müsste angepasst werden, wie Sie Zugriff auf die GORM-DB bekommen
|
|
|
|
// Beispiel (müsste angepasst werden):
|
|
// activityDS, ok := r.ActivityDatasource.(*ds.ActivityDatasource)
|
|
// if !ok {
|
|
// return nil, fmt.Errorf("Konnte GORM-DB nicht aus ActivityDatasource extrahieren")
|
|
// }
|
|
// return activityDS.GetDB(), nil
|
|
|
|
// Placeholder für die tatsächliche Implementierung:
|
|
return nil, fmt.Errorf("getGormDB() muss implementiert werden")
|
|
}
|