first commit

2025-07-07 01:44:12 +02:00
commit bf68bde4ce
72 changed files with 29002 additions and 0 deletions
@@ -0,0 +1,894 @@
+package database
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"tankstopp/internal/models"
+	"time"
+
+	"golang.org/x/crypto/bcrypt"
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+type DB struct {
+	conn *gorm.DB
+}
+
+// NewDB creates a new database connection using GORM with configuration
+func NewDB(config *Config) (*DB, error) {
+	// Validate configuration
+	if err := config.Validate(); err != nil {
+		return nil, fmt.Errorf("invalid configuration: %w", err)
+	}
+
+	// Configure GORM
+	gormConfig := &gorm.Config{
+		Logger:                                   logger.Default.LogMode(config.LogLevel),
+		PrepareStmt:                              config.PrepareStmt,
+		DisableForeignKeyConstraintWhenMigrating: config.DisableForeignKeyCheck,
+		IgnoreRelationshipsWhenMigrating:         config.IgnoreRelationshipsWhenMigrating,
+		QueryFields:                              config.QueryFields,
+		CreateBatchSize:                          config.CreateBatchSize,
+		DryRun:                                   config.DryRun,
+	}
+
+	// Configure slow query logging
+	if config.SlowQueryLog > 0 {
+		env := os.Getenv("ENV")
+		isDev := env == "development" || env == "dev" || env == ""
+
+		customLogger := logger.New(
+			log.New(os.Stdout, "\r\n", log.LstdFlags), // io writer
+			logger.Config{
+				SlowThreshold:             config.SlowQueryLog,
+				LogLevel:                  config.LogLevel,
+				IgnoreRecordNotFoundError: true,
+				Colorful:                  isDev,
+			},
+		)
+		gormConfig.Logger = customLogger
+	}
+
+	conn, err := gorm.Open(sqlite.Open(config.DatabasePath), gormConfig)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open database: %w", err)
+	}
+
+	// Get underlying SQL DB to configure connection pool
+	sqlDB, err := conn.DB()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get underlying sql.DB: %w", err)
+	}
+
+	// Set connection pool settings from configuration
+	sqlDB.SetMaxIdleConns(config.MaxIdleConns)
+	sqlDB.SetMaxOpenConns(config.MaxOpenConns)
+	sqlDB.SetConnMaxLifetime(config.ConnMaxLifetime)
+	sqlDB.SetConnMaxIdleTime(config.ConnMaxIdleTime)
+
+	db := &DB{conn: conn}
+
+	// Run migrations if enabled
+	if config.AutoMigrate {
+		if err := db.migrate(); err != nil {
+			return nil, fmt.Errorf("failed to migrate database: %w", err)
+		}
+	}
+
+	return db, nil
+}
+
+// NewDBWithDefaults creates a new database connection with default configuration
+func NewDBWithDefaults(databasePath string) (*DB, error) {
+	config := DefaultConfig()
+	config.DatabasePath = databasePath
+	return NewDB(config)
+}
+
+// NewDBFromEnv creates a new database connection using environment variables
+func NewDBFromEnv() (*DB, error) {
+	config := LoadFromEnv()
+	return NewDB(config)
+}
+
+// NewDBFromConfig creates a new database connection using configuration file
+func NewDBFromConfig(configPath string) (*DB, error) {
+	config := LoadFromConfig(configPath)
+	return NewDB(config)
+}
+
+// Close closes the database connection
+func (db *DB) Close() error {
+	sqlDB, err := db.conn.DB()
+	if err != nil {
+		return err
+	}
+	return sqlDB.Close()
+}
+
+// migrate runs database migrations
+func (db *DB) migrate() error {
+	// Auto-migrate the schema
+	return db.conn.AutoMigrate(&models.User{}, &models.Vehicle{}, &models.FuelStop{})
+}
+
+// CreateFuelStop inserts a new fuel stop into the database
+func (db *DB) CreateFuelStop(stop *models.FuelStop) error {
+	// Set timestamps
+	now := time.Now()
+	stop.CreatedAt = now
+	stop.UpdatedAt = now
+
+	result := db.conn.Create(stop)
+	if result.Error != nil {
+		return fmt.Errorf("failed to create fuel stop: %w", result.Error)
+	}
+
+	return nil
+}
+
+// GetFuelStops retrieves all fuel stops for a specific user from the database
+func (db *DB) GetFuelStops(userID uint) ([]models.FuelStop, error) {
+	var stops []models.FuelStop
+
+	result := db.conn.Preload("Vehicle").Where("user_id = ?", userID).
+		Order("date DESC").
+		Find(&stops)
+
+	if result.Error != nil {
+		return nil, fmt.Errorf("failed to get fuel stops: %w", result.Error)
+	}
+
+	return stops, nil
+}
+
+// GetFuelStopsByVehicle retrieves all fuel stops for a specific vehicle
+func (db *DB) GetFuelStopsByVehicle(vehicleID, userID uint) ([]models.FuelStop, error) {
+	var stops []models.FuelStop
+
+	result := db.conn.Where("vehicle_id = ? AND user_id = ?", vehicleID, userID).
+		Order("date DESC").
+		Find(&stops)
+
+	if result.Error != nil {
+		return nil, fmt.Errorf("failed to get fuel stops by vehicle: %w", result.Error)
+	}
+
+	return stops, nil
+}
+
+// GetFuelStopByID retrieves a fuel stop by its ID and user ID
+func (db *DB) GetFuelStopByID(id, userID uint) (*models.FuelStop, error) {
+	var stop models.FuelStop
+
+	result := db.conn.Where("id = ? AND user_id = ?", id, userID).First(&stop)
+	if result.Error != nil {
+		if result.Error == gorm.ErrRecordNotFound {
+			return nil, nil // Return nil when record not found
+		}
+		return nil, fmt.Errorf("failed to get fuel stop: %w", result.Error)
+	}
+
+	return &stop, nil
+}
+
+// UpdateFuelStop updates an existing fuel stop
+func (db *DB) UpdateFuelStop(stop *models.FuelStop) error {
+	// Update timestamp
+	stop.UpdatedAt = time.Now()
+
+	result := db.conn.Model(stop).
+		Where("id = ? AND user_id = ?", stop.ID, stop.UserID).
+		Updates(stop)
+
+	if result.Error != nil {
+		return fmt.Errorf("failed to update fuel stop: %w", result.Error)
+	}
+
+	if result.RowsAffected == 0 {
+		return fmt.Errorf("fuel stop not found or access denied")
+	}
+
+	return nil
+}
+
+// DeleteFuelStop deletes a fuel stop by its ID and user ID
+func (db *DB) DeleteFuelStop(id, userID uint) error {
+	result := db.conn.Where("id = ? AND user_id = ?", id, userID).Delete(&models.FuelStop{})
+	if result.Error != nil {
+		return fmt.Errorf("failed to delete fuel stop: %w", result.Error)
+	}
+
+	if result.RowsAffected == 0 {
+		return fmt.Errorf("fuel stop not found or access denied")
+	}
+
+	return nil
+}
+
+// CreateVehicle creates a new vehicle for a user
+func (db *DB) CreateVehicle(vehicle *models.Vehicle) error {
+	// Set timestamps
+	now := time.Now()
+	vehicle.CreatedAt = now
+	vehicle.UpdatedAt = now
+
+	result := db.conn.Create(vehicle)
+	if result.Error != nil {
+		return fmt.Errorf("failed to create vehicle: %w", result.Error)
+	}
+
+	return nil
+}
+
+// GetVehicles retrieves all vehicles for a specific user
+func (db *DB) GetVehicles(userID uint) ([]models.Vehicle, error) {
+	var vehicles []models.Vehicle
+
+	result := db.conn.Where("user_id = ?", userID).
+		Order("is_active DESC, name ASC").
+		Find(&vehicles)
+
+	if result.Error != nil {
+		return nil, fmt.Errorf("failed to get vehicles: %w", result.Error)
+	}
+
+	return vehicles, nil
+}
+
+// GetActiveVehicles retrieves only active vehicles for a specific user
+func (db *DB) GetActiveVehicles(userID uint) ([]models.Vehicle, error) {
+	var vehicles []models.Vehicle
+
+	result := db.conn.Where("user_id = ? AND is_active = ?", userID, true).
+		Order("name ASC").
+		Find(&vehicles)
+
+	if result.Error != nil {
+		return nil, fmt.Errorf("failed to get active vehicles: %w", result.Error)
+	}
+
+	return vehicles, nil
+}
+
+// GetVehicleByID retrieves a vehicle by its ID and user ID
+func (db *DB) GetVehicleByID(id, userID uint) (*models.Vehicle, error) {
+	var vehicle models.Vehicle
+
+	result := db.conn.Where("id = ? AND user_id = ?", id, userID).First(&vehicle)
+	if result.Error != nil {
+		if result.Error == gorm.ErrRecordNotFound {
+			return nil, nil // Return nil when vehicle not found
+		}
+		return nil, fmt.Errorf("failed to get vehicle: %w", result.Error)
+	}
+
+	return &vehicle, nil
+}
+
+// UpdateVehicle updates an existing vehicle
+func (db *DB) UpdateVehicle(vehicle *models.Vehicle) error {
+	// Update timestamp
+	vehicle.UpdatedAt = time.Now()
+
+	result := db.conn.Model(vehicle).
+		Where("id = ? AND user_id = ?", vehicle.ID, vehicle.UserID).
+		Updates(vehicle)
+
+	if result.Error != nil {
+		return fmt.Errorf("failed to update vehicle: %w", result.Error)
+	}
+
+	if result.RowsAffected == 0 {
+		return fmt.Errorf("vehicle not found or access denied")
+	}
+
+	return nil
+}
+
+// DeleteVehicle deletes a vehicle by its ID and user ID
+func (db *DB) DeleteVehicle(id, userID uint) error {
+	// Check if vehicle has fuel stops
+	var count int64
+	if err := db.conn.Model(&models.FuelStop{}).Where("vehicle_id = ?", id).Count(&count).Error; err != nil {
+		return fmt.Errorf("failed to check fuel stops: %w", err)
+	}
+
+	if count > 0 {
+		return fmt.Errorf("cannot delete vehicle with existing fuel stops")
+	}
+
+	result := db.conn.Where("id = ? AND user_id = ?", id, userID).Delete(&models.Vehicle{})
+	if result.Error != nil {
+		return fmt.Errorf("failed to delete vehicle: %w", result.Error)
+	}
+
+	if result.RowsAffected == 0 {
+		return fmt.Errorf("vehicle not found or access denied")
+	}
+
+	return nil
+}
+
+// GetVehicleWithFuelStops retrieves a vehicle with its fuel stops
+func (db *DB) GetVehicleWithFuelStops(vehicleID, userID uint) (*models.Vehicle, error) {
+	var vehicle models.Vehicle
+
+	result := db.conn.Preload("FuelStops", func(db *gorm.DB) *gorm.DB {
+		return db.Order("date DESC")
+	}).Where("id = ? AND user_id = ?", vehicleID, userID).First(&vehicle)
+
+	if result.Error != nil {
+		if result.Error == gorm.ErrRecordNotFound {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("failed to get vehicle with fuel stops: %w", result.Error)
+	}
+
+	return &vehicle, nil
+}
+
+// GetVehicleCount returns the total number of vehicles for a user
+func (db *DB) GetVehicleCount(userID uint) (int64, error) {
+	var count int64
+	result := db.conn.Model(&models.Vehicle{}).Where("user_id = ?", userID).Count(&count)
+	if result.Error != nil {
+		return 0, fmt.Errorf("failed to count vehicles: %w", result.Error)
+	}
+	return count, nil
+}
+
+// ValidateVehicle validates vehicle data before creation/update
+func (db *DB) ValidateVehicle(vehicle *models.Vehicle) error {
+	if vehicle.UserID == 0 {
+		return fmt.Errorf("user ID is required")
+	}
+
+	// Check if user exists
+	exists, err := db.UserExists(vehicle.UserID)
+	if err != nil {
+		return fmt.Errorf("failed to validate user: %w", err)
+	}
+	if !exists {
+		return fmt.Errorf("user does not exist")
+	}
+
+	if vehicle.Name == "" {
+		return fmt.Errorf("vehicle name is required")
+	}
+
+	if len(vehicle.Name) > 100 {
+		return fmt.Errorf("vehicle name must be 100 characters or less")
+	}
+
+	if vehicle.Make != "" && len(vehicle.Make) > 50 {
+		return fmt.Errorf("vehicle make must be 50 characters or less")
+	}
+
+	if vehicle.Model != "" && len(vehicle.Model) > 50 {
+		return fmt.Errorf("vehicle model must be 50 characters or less")
+	}
+
+	if vehicle.LicensePlate != "" && len(vehicle.LicensePlate) > 20 {
+		return fmt.Errorf("license plate must be 20 characters or less")
+	}
+
+	if vehicle.FuelType != "" && len(vehicle.FuelType) > 50 {
+		return fmt.Errorf("fuel type must be 50 characters or less")
+	}
+
+	if vehicle.Year < 0 || vehicle.Year > time.Now().Year()+1 {
+		return fmt.Errorf("invalid vehicle year")
+	}
+
+	return nil
+}
+
+// CreateVehicleWithValidation creates a vehicle with validation
+func (db *DB) CreateVehicleWithValidation(vehicle *models.Vehicle) error {
+	if err := db.ValidateVehicle(vehicle); err != nil {
+		return fmt.Errorf("validation failed: %w", err)
+	}
+
+	return db.CreateVehicle(vehicle)
+}
+
+// GetFuelStopStats calculates statistics for fuel consumption for a specific user
+func (db *DB) GetFuelStopStats(userID uint) (*models.FuelStopStats, error) {
+	stats := &models.FuelStopStats{}
+
+	// Get basic statistics
+	var result struct {
+		TotalStops   int64   `json:"total_stops"`
+		TotalLiters  float64 `json:"total_liters"`
+		TotalSpent   float64 `json:"total_spent"`
+		AveragePrice float64 `json:"average_price"`
+		TotalTripKm  float64 `json:"total_trip_km"`
+		MinOdometer  int     `json:"min_odometer"`
+		MaxOdometer  int     `json:"max_odometer"`
+	}
+
+	err := db.conn.Model(&models.FuelStop{}).
+		Select(`
+			COUNT(*) as total_stops,
+			COALESCE(SUM(liters), 0) as total_liters,
+			COALESCE(SUM(total_price), 0) as total_spent,
+			COALESCE(AVG(price_per_l), 0) as average_price,
+			COALESCE(SUM(trip_length), 0) as total_trip_km,
+			COALESCE(MIN(odometer), 0) as min_odometer,
+			COALESCE(MAX(odometer), 0) as max_odometer
+		`).
+		Where("user_id = ?", userID).
+		Scan(&result).Error
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to get fuel stop stats: %w", err)
+	}
+
+	stats.TotalStops = int(result.TotalStops)
+	stats.TotalLiters = result.TotalLiters
+	stats.TotalSpent = result.TotalSpent
+	stats.AveragePrice = result.AveragePrice
+
+	// Get the last fillup
+	var lastStop models.FuelStop
+	err = db.conn.Where("user_id = ?", userID).
+		Order("date DESC").
+		First(&lastStop).Error
+
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return nil, fmt.Errorf("failed to get last fillup: %w", err)
+	}
+
+	if err != gorm.ErrRecordNotFound {
+		stats.LastFillup = &lastStop
+	}
+
+	// Calculate average consumption using trip length (preferred) or odometer difference (fallback)
+	if stats.TotalStops > 1 {
+		// Primary method: Use trip length if available
+		if result.TotalTripKm > 0 {
+			stats.AverageConsumption = (stats.TotalLiters / result.TotalTripKm) * 100
+		} else if result.MaxOdometer > result.MinOdometer {
+			// Fallback method: Use odometer difference
+			distanceDriven := result.MaxOdometer - result.MinOdometer
+			if distanceDriven > 0 {
+				stats.AverageConsumption = (stats.TotalLiters / float64(distanceDriven)) * 100
+			}
+		}
+	}
+
+	return stats, nil
+
+}
+
+// CreateUser creates a new user in the database
+func (db *DB) CreateUser(user *models.User) error {
+	// Hash the password
+	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(user.Password), bcrypt.DefaultCost)
+	if err != nil {
+		return fmt.Errorf("failed to hash password: %w", err)
+	}
+
+	user.PasswordHash = string(hashedPassword)
+	user.Password = "" // Clear the plain text password
+
+	// Set timestamps
+	now := time.Now()
+	user.CreatedAt = now
+	user.UpdatedAt = now
+
+	result := db.conn.Create(user)
+	if result.Error != nil {
+		return fmt.Errorf("failed to create user: %w", result.Error)
+	}
+
+	return nil
+}
+
+// GetUserByUsername retrieves a user by username
+func (db *DB) GetUserByUsername(username string) (*models.User, error) {
+	var user models.User
+
+	result := db.conn.Where("username = ?", username).First(&user)
+	if result.Error != nil {
+		if result.Error == gorm.ErrRecordNotFound {
+			return nil, nil // Return nil when user not found
+		}
+		return nil, fmt.Errorf("failed to get user by username: %w", result.Error)
+	}
+
+	return &user, nil
+}
+
+// GetUserByID retrieves a user by ID
+func (db *DB) GetUserByID(id uint) (*models.User, error) {
+	var user models.User
+
+	result := db.conn.First(&user, id)
+	if result.Error != nil {
+		if result.Error == gorm.ErrRecordNotFound {
+			return nil, nil // Return nil when user not found
+		}
+		return nil, fmt.Errorf("failed to get user by ID: %w", result.Error)
+	}
+
+	return &user, nil
+}
+
+// UpdateUser updates an existing user
+func (db *DB) UpdateUser(user *models.User) error {
+	// Update timestamp
+	user.UpdatedAt = time.Now()
+
+	result := db.conn.Model(user).
+		Select("email", "base_currency", "updated_at").
+		Updates(user)
+
+	if result.Error != nil {
+		return fmt.Errorf("failed to update user: %w", result.Error)
+	}
+
+	if result.RowsAffected == 0 {
+		return fmt.Errorf("user not found")
+	}
+
+	return nil
+}
+
+// UpdateUserPassword updates a user's password
+func (db *DB) UpdateUserPassword(user *models.User, newPassword string) error {
+	// Hash the new password
+	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(newPassword), bcrypt.DefaultCost)
+	if err != nil {
+		return fmt.Errorf("failed to hash password: %w", err)
+	}
+
+	// Update timestamp
+	now := time.Now()
+
+	// Update only the password hash and updated_at fields
+	result := db.conn.Model(user).
+		Updates(map[string]interface{}{
+			"password_hash": string(hashedPassword),
+			"updated_at":    now,
+		})
+
+	if result.Error != nil {
+		return fmt.Errorf("failed to update password: %w", result.Error)
+	}
+
+	if result.RowsAffected == 0 {
+		return fmt.Errorf("user not found")
+	}
+
+	// Update the user object with new password hash
+	user.PasswordHash = string(hashedPassword)
+	user.UpdatedAt = now
+
+	return nil
+}
+
+// GetUserByEmail retrieves a user by email
+func (db *DB) GetUserByEmail(email string) (*models.User, error) {
+	var user models.User
+
+	result := db.conn.Where("email = ?", email).First(&user)
+	if result.Error != nil {
+		if result.Error == gorm.ErrRecordNotFound {
+			return nil, nil // Return nil when user not found
+		}
+		return nil, fmt.Errorf("failed to get user by email: %w", result.Error)
+	}
+
+	return &user, nil
+}
+
+// GetUserWithFuelStops retrieves a user with their fuel stops
+func (db *DB) GetUserWithFuelStops(userID uint) (*models.User, error) {
+	var user models.User
+
+	result := db.conn.Preload("FuelStops", func(db *gorm.DB) *gorm.DB {
+		return db.Order("date DESC")
+	}).Preload("Vehicles").First(&user, userID)
+
+	if result.Error != nil {
+		if result.Error == gorm.ErrRecordNotFound {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("failed to get user with fuel stops: %w", result.Error)
+	}
+
+	return &user, nil
+}
+
+// GetFuelStopsWithPagination retrieves fuel stops with pagination
+func (db *DB) GetFuelStopsWithPagination(userID uint, limit, offset int) ([]models.FuelStop, int64, error) {
+	var stops []models.FuelStop
+	var total int64
+
+	// Get total count
+	err := db.conn.Model(&models.FuelStop{}).
+		Where("user_id = ?", userID).
+		Count(&total).Error
+
+	if err != nil {
+		return nil, 0, fmt.Errorf("failed to count fuel stops: %w", err)
+	}
+
+	// Get paginated results
+	err = db.conn.Where("user_id = ?", userID).
+		Order("date DESC").
+		Limit(limit).
+		Offset(offset).
+		Find(&stops).Error
+
+	if err != nil {
+		return nil, 0, fmt.Errorf("failed to get fuel stops with pagination: %w", err)
+	}
+
+	return stops, total, nil
+}
+
+// GetFuelStopsByDateRange retrieves fuel stops within a date range
+func (db *DB) GetFuelStopsByDateRange(userID uint, startDate, endDate time.Time) ([]models.FuelStop, error) {
+	var stops []models.FuelStop
+
+	result := db.conn.Where("user_id = ? AND date BETWEEN ? AND ?", userID, startDate, endDate).
+		Order("date DESC").
+		Find(&stops)
+
+	if result.Error != nil {
+		return nil, fmt.Errorf("failed to get fuel stops by date range: %w", result.Error)
+	}
+
+	return stops, nil
+}
+
+// GetFuelStopsByFuelType retrieves fuel stops by fuel type
+func (db *DB) GetFuelStopsByFuelType(userID uint, fuelType string) ([]models.FuelStop, error) {
+	var stops []models.FuelStop
+
+	result := db.conn.Where("user_id = ? AND fuel_type = ?", userID, fuelType).
+		Order("date DESC").
+		Find(&stops)
+
+	if result.Error != nil {
+		return nil, fmt.Errorf("failed to get fuel stops by fuel type: %w", result.Error)
+	}
+
+	return stops, nil
+}
+
+// GetMonthlyStats retrieves monthly statistics for a user
+func (db *DB) GetMonthlyStats(userID uint, year int) ([]models.MonthlyStats, error) {
+	var stats []models.MonthlyStats
+
+	query := `
+		SELECT
+			strftime('%m', date) as month,
+			strftime('%Y', date) as year,
+			COUNT(*) as total_stops,
+			SUM(liters) as total_liters,
+			SUM(total_price) as total_spent,
+			AVG(price_per_l) as average_price
+		FROM fuel_stops
+		WHERE user_id = ? AND strftime('%Y', date) = ?
+		GROUP BY strftime('%Y-%m', date)
+		ORDER BY month
+	`
+
+	err := db.conn.Raw(query, userID, fmt.Sprintf("%d", year)).Scan(&stats).Error
+	if err != nil {
+		return nil, fmt.Errorf("failed to get monthly stats: %w", err)
+	}
+
+	return stats, nil
+}
+
+// BulkCreateFuelStops creates multiple fuel stops in a single transaction
+func (db *DB) BulkCreateFuelStops(stops []models.FuelStop) error {
+	if len(stops) == 0 {
+		return nil
+	}
+
+	// Set timestamps for all stops
+	now := time.Now()
+	for i := range stops {
+		stops[i].CreatedAt = now
+		stops[i].UpdatedAt = now
+	}
+
+	// Use transaction for bulk insert
+	return db.conn.Transaction(func(tx *gorm.DB) error {
+		return tx.CreateInBatches(stops, 100).Error
+	})
+}
+
+// DeleteAllUserData deletes all data for a user (for account deletion)
+func (db *DB) DeleteAllUserData(userID uint) error {
+	return db.conn.Transaction(func(tx *gorm.DB) error {
+		// Delete all fuel stops first (due to foreign key constraint)
+		if err := tx.Where("user_id = ?", userID).Delete(&models.FuelStop{}).Error; err != nil {
+			return fmt.Errorf("failed to delete fuel stops: %w", err)
+		}
+
+		// Delete the user
+		if err := tx.Delete(&models.User{}, userID).Error; err != nil {
+			return fmt.Errorf("failed to delete user: %w", err)
+		}
+
+		return nil
+	})
+}
+
+// HealthCheck performs a simple health check on the database
+func (db *DB) HealthCheck() error {
+	sqlDB, err := db.conn.DB()
+	if err != nil {
+		return fmt.Errorf("failed to get underlying sql.DB: %w", err)
+	}
+
+	return sqlDB.Ping()
+}
+
+// GetFuelStopCount returns the total number of fuel stops for a user
+func (db *DB) GetFuelStopCount(userID uint) (int64, error) {
+	var count int64
+	result := db.conn.Model(&models.FuelStop{}).Where("user_id = ?", userID).Count(&count)
+	if result.Error != nil {
+		return 0, fmt.Errorf("failed to count fuel stops: %w", result.Error)
+	}
+	return count, nil
+}
+
+// GetLatestFuelStop returns the most recent fuel stop for a user
+func (db *DB) GetLatestFuelStop(userID uint) (*models.FuelStop, error) {
+	var stop models.FuelStop
+	result := db.conn.Where("user_id = ?", userID).Order("date DESC").First(&stop)
+	if result.Error != nil {
+		if result.Error == gorm.ErrRecordNotFound {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("failed to get latest fuel stop: %w", result.Error)
+	}
+	return &stop, nil
+}
+
+// UserExists checks if a user exists by ID
+func (db *DB) UserExists(userID uint) (bool, error) {
+	var count int64
+	result := db.conn.Model(&models.User{}).Where("id = ?", userID).Count(&count)
+	if result.Error != nil {
+		return false, fmt.Errorf("failed to check user existence: %w", result.Error)
+	}
+	return count > 0, nil
+}
+
+// ValidateFuelStop validates fuel stop data before creation/update
+func (db *DB) ValidateFuelStop(stop *models.FuelStop) error {
+	if stop.UserID == 0 {
+		return fmt.Errorf("user ID is required")
+	}
+
+	// Check if user exists
+	exists, err := db.UserExists(stop.UserID)
+	if err != nil {
+		return fmt.Errorf("failed to validate user: %w", err)
+	}
+	if !exists {
+		return fmt.Errorf("user does not exist")
+	}
+
+	if stop.Date.IsZero() {
+		return fmt.Errorf("date is required")
+	}
+
+	if stop.StationName == "" {
+		return fmt.Errorf("station name is required")
+	}
+
+	if stop.Location == "" {
+		return fmt.Errorf("location is required")
+	}
+
+	if stop.FuelType == "" {
+		return fmt.Errorf("fuel type is required")
+	}
+
+	if stop.Liters <= 0 {
+		return fmt.Errorf("liters must be greater than 0")
+	}
+
+	if stop.PricePerL <= 0 {
+		return fmt.Errorf("price per liter must be greater than 0")
+	}
+
+	if stop.TotalPrice <= 0 {
+		return fmt.Errorf("total price must be greater than 0")
+	}
+
+	if stop.Currency == "" {
+		stop.Currency = "EUR" // Set default currency
+	}
+
+	if stop.TripLength < 0 {
+		return fmt.Errorf("trip length cannot be negative")
+	}
+
+	if stop.VehicleID == 0 {
+		return fmt.Errorf("vehicle is required")
+	}
+
+	// Check if vehicle exists and belongs to user
+	vehicle, err := db.GetVehicleByID(stop.VehicleID, stop.UserID)
+	if err != nil {
+		return fmt.Errorf("failed to validate vehicle: %w", err)
+	}
+	if vehicle == nil {
+		return fmt.Errorf("vehicle does not exist or access denied")
+	}
+
+	return nil
+}
+
+// CreateFuelStopWithValidation creates a fuel stop with validation
+func (db *DB) CreateFuelStopWithValidation(stop *models.FuelStop) error {
+	if err := db.ValidateFuelStop(stop); err != nil {
+		return fmt.Errorf("validation failed: %w", err)
+	}
+
+	return db.CreateFuelStop(stop)
+}
+
+// GetFuelStopsWithUser retrieves fuel stops with user information preloaded
+func (db *DB) GetFuelStopsWithUser(userID uint) ([]models.FuelStop, error) {
+	var stops []models.FuelStop
+
+	result := db.conn.Preload("User").Preload("Vehicle").
+		Where("user_id = ?", userID).
+		Order("date DESC").
+		Find(&stops)
+
+	if result.Error != nil {
+		return nil, fmt.Errorf("failed to get fuel stops with user: %w", result.Error)
+	}
+
+	return stops, nil
+}
+
+// SearchFuelStops performs a text search across station names and locations
+func (db *DB) SearchFuelStops(userID uint, searchTerm string) ([]models.FuelStop, error) {
+	var stops []models.FuelStop
+
+	searchPattern := "%" + searchTerm + "%"
+	result := db.conn.Where("user_id = ? AND (station_name LIKE ? OR location LIKE ?)",
+		userID, searchPattern, searchPattern).
+		Order("date DESC").
+		Find(&stops)
+
+	if result.Error != nil {
+		return nil, fmt.Errorf("failed to search fuel stops: %w", result.Error)
+	}
+
+	return stops, nil
+}
+
+// GetRecentFuelStops returns the most recent N fuel stops for a user
+func (db *DB) GetRecentFuelStops(userID uint, limit int) ([]models.FuelStop, error) {
+	var stops []models.FuelStop
+
+	result := db.conn.Where("user_id = ?", userID).
+		Order("date DESC").
+		Limit(limit).
+		Find(&stops)
+
+	if result.Error != nil {
+		return nil, fmt.Errorf("failed to get recent fuel stops: %w", result.Error)
+	}
+
+	return stops, nil
+}