package model import ( "database/sql" "fmt" "strings" ) // Vehicle repräsentiert ein Fahrzeug. type Vehicle struct { ID int `json:"id"` Name string `json:"name"` Manufacturer *string `json:"manufacturer,omitempty"` Model *string `json:"model,omitempty"` Year *int `json:"year,omitempty"` Description *string `json:"description,omitempty"` LicensePlate *string `json:"license_plate,omitempty"` PurchaseDate *string `json:"purchase_date,omitempty"` WeightKg *float64 `json:"weight_kg,omitempty"` PowerKw *float64 `json:"power_kw,omitempty"` MaxOdometer *float64 `json:"max_odometer,omitempty"` CurrentOdometer float64 `json:"current_odometer"` FuelID *int `json:"fuel_id,omitempty"` CreatedAt string `json:"created_at"` UpdatedAt string `json:"updated_at"` } // VehicleListEntry ist eine kompakte Darstellung für die Fahrzeugliste. type VehicleListEntry struct { ID int `json:"id"` Name string `json:"name"` Manufacturer *string `json:"manufacturer,omitempty"` Model *string `json:"model,omitempty"` FuelName *string `json:"fuel_name,omitempty"` FuelID *int `json:"fuel_id,omitempty"` PowerKw *float64 `json:"power_kw,omitempty"` CurrentOdometer float64 `json:"current_odometer"` } // VehicleDetail enthält ein Fahrzeug mit zugehörigen Kraftstoff-Details. type VehicleDetail struct { Vehicle Fuel *Fuel `json:"fuel,omitempty"` } // CreateVehicle fügt ein neues Fahrzeug in die Datenbank ein. func CreateVehicle(db *sql.DB, v *Vehicle) error { query := `INSERT INTO vehicles (name, manufacturer, model, year, description, license_plate, purchase_date, weight_kg, power_kw, max_odometer, current_odometer, fuel_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)` result, err := db.Exec(query, v.Name, v.Manufacturer, v.Model, v.Year, v.Description, v.LicensePlate, v.PurchaseDate, v.WeightKg, v.PowerKw, v.MaxOdometer, v.CurrentOdometer, v.FuelID, ) if err != nil { return err } lastID, err := result.LastInsertId() if err != nil { return err } v.ID = int(lastID) return nil } // GetVehicles listet Fahrzeuge mit optionalen Filtern und Paginierung. // Gibt ([]VehicleListEntry, total_count, error) zurück. func GetVehicles(db *sql.DB, filters map[string]string, limit, offset int) ([]VehicleListEntry, int, error) { whereClauses := []string{} args := []interface{}{} if v, ok := filters["name"]; ok && v != "" { whereClauses = append(whereClauses, "v.name LIKE ?") args = append(args, "%"+v+"%") } if v, ok := filters["license_plate"]; ok && v != "" { whereClauses = append(whereClauses, "v.license_plate = ?") args = append(args, v) } if v, ok := filters["fuel_id"]; ok && v != "" { var fuelID int if _, err := fmt.Sscanf(v, "%d", &fuelID); err == nil { whereClauses = append(whereClauses, "v.fuel_id = ?") args = append(args, fuelID) } } if v, ok := filters["manufacturer"]; ok && v != "" { whereClauses = append(whereClauses, "v.manufacturer LIKE ?") args = append(args, "%"+v+"%") } if v, ok := filters["model"]; ok && v != "" { whereClauses = append(whereClauses, "v.model LIKE ?") args = append(args, "%"+v+"%") } if v, ok := filters["year"]; ok && v != "" { var year int if _, err := fmt.Sscanf(v, "%d", &year); err == nil { whereClauses = append(whereClauses, "v.year = ?") args = append(args, year) } } whereSQL := "" if len(whereClauses) > 0 { whereSQL = "WHERE " + strings.Join(whereClauses, " AND ") } // Gesamtanzahl ermitteln countQuery := fmt.Sprintf("SELECT COUNT(*) FROM vehicles v %s", whereSQL) var total int err := db.QueryRow(countQuery, args...).Scan(&total) if err != nil { return nil, 0, err } // Fahrzeuge ermitteln query := fmt.Sprintf(` SELECT v.id, v.name, v.manufacturer, v.model, f.name, v.fuel_id, v.power_kw, v.current_odometer FROM vehicles v LEFT JOIN fuels f ON v.fuel_id = f.id %s ORDER BY v.id LIMIT ? OFFSET ?`, whereSQL) args = append(args, limit, offset) rows, err := db.Query(query, args...) if err != nil { return nil, 0, err } defer rows.Close() var vehicles []VehicleListEntry for rows.Next() { var v VehicleListEntry if err := rows.Scan( &v.ID, &v.Name, &v.Manufacturer, &v.Model, &v.FuelName, &v.FuelID, &v.PowerKw, &v.CurrentOdometer, ); err != nil { return nil, 0, err } vehicles = append(vehicles, v) } return vehicles, total, rows.Err() } // GetVehicleByID liest ein einzelnes Fahrzeug inkl. Kraftstoffdetails. func GetVehicleByID(db *sql.DB, id int) (*VehicleDetail, error) { var vd VehicleDetail var fuelID *int var fuelName, fuelUnit string err := db.QueryRow(` SELECT v.id, v.name, v.manufacturer, v.model, v.year, v.description, v.license_plate, v.purchase_date, v.weight_kg, v.power_kw, v.max_odometer, v.current_odometer, v.fuel_id, v.created_at, v.updated_at, f.id, f.name, f.unit FROM vehicles v LEFT JOIN fuels f ON v.fuel_id = f.id WHERE v.id = ? `, id).Scan( &vd.ID, &vd.Name, &vd.Manufacturer, &vd.Model, &vd.Year, &vd.Description, &vd.LicensePlate, &vd.PurchaseDate, &vd.WeightKg, &vd.PowerKw, &vd.MaxOdometer, &vd.CurrentOdometer, &vd.FuelID, &vd.CreatedAt, &vd.UpdatedAt, &fuelID, &fuelName, &fuelUnit, ) if err == sql.ErrNoRows { return nil, nil } if err != nil { return nil, err } // NULL-Felder prüfen: wenn f.id NULL war, Fuel auf nil setzen if fuelID != nil && *fuelID >= 0 && fuelName != "" { vd.FuelID = fuelID vd.Fuel = &Fuel{ID: *fuelID, Name: fuelName, Unit: fuelUnit} } return &vd, nil } // UpdateOdometer aktualisiert den aktuellen Kilometerstand eines Fahrzeugs. func UpdateOdometer(db *sql.DB, vehicleID int, newOdometer float64) error { _, err := db.Exec( "UPDATE vehicles SET current_odometer = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?", newOdometer, vehicleID, ) return err }