Initial commit: gocarlog project — Milestones 1-10 completed

This commit is contained in:
2026-06-07 11:57:42 +02:00
commit 1d17422093
29 changed files with 4532 additions and 0 deletions
+45
View File
@@ -0,0 +1,45 @@
package model
import (
"database/sql"
"fmt"
)
// Fuel repräsentiert einen Kraftstofftyp.
type Fuel struct {
ID int `json:"id"`
Name string `json:"name"`
Unit string `json:"unit"`
}
// GetFuels liest alle Kraftstofftypen aus der Datenbank.
func GetFuels(db *sql.DB) ([]Fuel, error) {
rows, err := db.Query("SELECT id, name, unit FROM fuels ORDER BY id")
if err != nil {
return nil, err
}
defer rows.Close()
var fuels []Fuel
for rows.Next() {
var f Fuel
if err := rows.Scan(&f.ID, &f.Name, &f.Unit); err != nil {
return nil, err
}
fuels = append(fuels, f)
}
return fuels, rows.Err()
}
// GetFuelByID liest einen einzelnen Kraftstofftyp nach ID.
func GetFuelByID(db *sql.DB, id int) (*Fuel, error) {
var f Fuel
err := db.QueryRow("SELECT id, name, unit FROM fuels WHERE id = ?", id).Scan(&f.ID, &f.Name, &f.Unit)
if err == sql.ErrNoRows {
return nil, fmt.Errorf("fuel with id %d not found", id)
}
if err != nil {
return nil, err
}
return &f, nil
}
+398
View File
@@ -0,0 +1,398 @@
package model
import (
"database/sql"
"fmt"
"strings"
)
// Log repräsentiert einen Logbucheintrag (Tankung, Wartung, Reparatur, Notiz).
type Log struct {
ID int `json:"id"`
VehicleID int `json:"vehicle_id"`
FuelID *int `json:"fuel_id,omitempty"`
LogType string `json:"log_type"`
Odometer float64 `json:"odometer"`
Datetime string `json:"datetime"`
Cost float64 `json:"cost"`
Quantity float64 `json:"quantity"`
Unit *string `json:"unit,omitempty"`
Note *string `json:"note,omitempty"`
CreatedAt string `json:"created_at"`
}
// LogWithVehicle enthält einen Logeintrag mit Fahrzeugname und optional Kraftstoff.
type LogWithVehicle struct {
Log
VehicleName string `json:"vehicle_name"`
Fuel *Fuel `json:"fuel,omitempty"`
ConsumptionPer100Km *string `json:"consumption_per_100km,omitempty"` // berechnet für Tankungen
}
// CostSummary fasst die Kosten pro Log-Typ zusammen.
type CostSummary struct {
Tankung float64 `json:"tankung"`
Wartung float64 `json:"wartung"`
Reparatur float64 `json:"reparatur"`
Notiz float64 `json:"notiz"`
}
// ConsumptionResult enthält berechnete Verbrauchswerte für ein Fahrzeug.
type ConsumptionResult struct {
VehicleID int `json:"vehicle_id"`
VehicleName string `json:"vehicle_name"`
FuelName *string `json:"fuel_name,omitempty"`
FuelUnit *string `json:"fuel_unit,omitempty"`
TotalFuel float64 `json:"total_fuel"`
TotalDistance float64 `json:"total_distance"`
AverageConsumption *float64 `json:"average_consumption"`
ConsumptionUnit string `json:"consumption_unit"`
PeriodFrom *string `json:"period_from,omitempty"`
PeriodTo *string `json:"period_to,omitempty"`
}
// CreateLog fügt einen Logeintrag ein und aktualisiert bei Bedarf den Odometer.
// Kopiert außerdem die Kraftstoff-Einheit aus der fuels-Tabelle.
func CreateLog(db *sql.DB, l *Log) error {
tx, err := db.Begin()
if err != nil {
return err
}
defer tx.Rollback()
// 1. Kraftstoff-Einheit aus der Datenbank holen (falls fuel_id gesetzt)
if l.FuelID != nil {
var fuelUnit string
err = tx.QueryRow("SELECT unit FROM fuels WHERE id = ?", *l.FuelID).Scan(&fuelUnit)
if err != nil {
return fmt.Errorf("get fuel unit: %w", err)
}
l.Unit = &fuelUnit
}
// 2. INSERT INTO logs
query := `INSERT INTO logs
(vehicle_id, fuel_id, log_type, odometer, datetime, cost, quantity, unit, note, created_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)`
result, err := tx.Exec(query,
l.VehicleID,
l.FuelID,
l.LogType,
l.Odometer,
l.Datetime,
l.Cost,
l.Quantity,
l.Unit,
l.Note,
)
if err != nil {
return fmt.Errorf("insert log: %w", err)
}
lastID, err := result.LastInsertId()
if err != nil {
return fmt.Errorf("get last insert id: %w", err)
}
l.ID = int(lastID)
// 3. SELECT current_odometer FROM vehicles
var currentOdometer float64
err = tx.QueryRow("SELECT current_odometer FROM vehicles WHERE id = ?", l.VehicleID).Scan(&currentOdometer)
if err != nil {
return fmt.Errorf("get current odometer: %w", err)
}
// 4. Falls newOdometer > current_odometer: UPDATE vehicles
if l.Odometer > currentOdometer {
_, err = tx.Exec(
"UPDATE vehicles SET current_odometer = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?",
l.Odometer, l.VehicleID,
)
if err != nil {
return fmt.Errorf("update odometer: %w", err)
}
}
return tx.Commit()
}
// GetLogs listet Logbucheinträge mit Fahrzeugname, Kraftstoffdetails und Kostensumme.
func GetLogs(db *sql.DB, filters map[string]string, limit, offset int) ([]LogWithVehicle, int, CostSummary, error) {
whereClauses := []string{}
args := []interface{}{}
if v, ok := filters["vehicle_id"]; ok && v != "" {
var vehicleID int
if _, err := fmt.Sscanf(v, "%d", &vehicleID); err == nil {
whereClauses = append(whereClauses, "l.vehicle_id = ?")
args = append(args, vehicleID)
}
}
if v, ok := filters["log_type"]; ok && v != "" {
whereClauses = append(whereClauses, "l.log_type = ?")
args = append(args, v)
}
if v, ok := filters["date_from"]; ok && v != "" {
whereClauses = append(whereClauses, "l.datetime >= ?")
args = append(args, v)
}
if v, ok := filters["date_to"]; ok && v != "" {
whereClauses = append(whereClauses, "l.datetime <= ?")
args = append(args, v)
}
whereSQL := ""
if len(whereClauses) > 0 {
whereSQL = "WHERE " + strings.Join(whereClauses, " AND ")
}
// Gesamtanzahl
countQuery := fmt.Sprintf("SELECT COUNT(*) FROM logs l %s", whereSQL)
var total int
err := db.QueryRow(countQuery, args...).Scan(&total)
if err != nil {
return nil, 0, CostSummary{}, err
}
// Logs mit JOINs
query := fmt.Sprintf(`
SELECT l.id, l.vehicle_id, l.fuel_id, l.log_type, l.odometer, l.datetime,
l.cost, l.quantity, l.unit, l.note, l.created_at,
v.name,
f.id, f.name, f.unit
FROM logs l
JOIN vehicles v ON l.vehicle_id = v.id
LEFT JOIN fuels f ON l.fuel_id = f.id
%s
ORDER BY l.id DESC
LIMIT ? OFFSET ?`, whereSQL)
args = append(args, limit, offset)
rows, err := db.Query(query, args...)
if err != nil {
return nil, 0, CostSummary{}, err
}
defer rows.Close()
var logs []LogWithVehicle
for rows.Next() {
var lwv LogWithVehicle
var fuelID *int
var fuelName *string
var fuelUnit *string
err := rows.Scan(
&lwv.ID, &lwv.VehicleID, &lwv.FuelID, &lwv.LogType, &lwv.Odometer, &lwv.Datetime,
&lwv.Cost, &lwv.Quantity, &lwv.Unit, &lwv.Note, &lwv.CreatedAt,
&lwv.VehicleName,
&fuelID, &fuelName, &fuelUnit,
)
if err != nil {
return nil, 0, CostSummary{}, err
}
lwv.FuelID = fuelID
if fuelID != nil && *fuelID > 0 && fuelName != nil {
lwv.Fuel = &Fuel{
ID: *fuelID,
Name: *fuelName,
Unit: *fuelUnit,
}
}
logs = append(logs, lwv)
}
if err := rows.Err(); err != nil {
return nil, 0, CostSummary{}, err
}
// Kostensumme ermitteln
var summary CostSummary
sumQuery := fmt.Sprintf(`
SELECT
COALESCE(SUM(CASE WHEN log_type = 'tankung' THEN cost ELSE 0 END), 0),
COALESCE(SUM(CASE WHEN log_type = 'wartung' THEN cost ELSE 0 END), 0),
COALESCE(SUM(CASE WHEN log_type = 'reparatur' THEN cost ELSE 0 END), 0),
COALESCE(SUM(CASE WHEN log_type = 'notiz' THEN cost ELSE 0 END), 0)
FROM logs l
%s`, whereSQL)
err = db.QueryRow(sumQuery, args[:len(args)-2]...).Scan(
&summary.Tankung, &summary.Wartung, &summary.Reparatur, &summary.Notiz,
)
if err != nil {
return nil, 0, CostSummary{}, err
}
// Verbrauch pro Tankung berechnen (Gruppierung nach Fahrzeug, sortiert nach datetime)
calculateConsumption(logs)
return logs, total, summary, nil
}
// calculateConsumption berechnet für jede Tankung den Verbrauch seit der vorherigen Tankung desselben Fahrzeugs.
func calculateConsumption(logs []LogWithVehicle) {
// 1. Nach Fahrzeug gruppieren
vehicleLogs := make(map[int][]*LogWithVehicle)
for i := range logs {
log := &logs[i]
vehicleLogs[log.VehicleID] = append(vehicleLogs[log.VehicleID], log)
}
// 2. Für jedes Fahrzeug nach datetime sortieren
for _, vLogs := range vehicleLogs {
// Bubble-sort (kleine Liste, einfach)
for i := 0; i < len(vLogs); i++ {
for j := i + 1; j < len(vLogs); j++ {
if vLogs[i].Datetime > vLogs[j].Datetime {
vLogs[i], vLogs[j] = vLogs[j], vLogs[i]
}
}
}
// 3. Durchgehen und Verbrauch berechnen
var prevOdometer *float64
var prevUnit *string
for _, log := range vLogs {
if log.LogType == "tankung" && log.Quantity > 0 && prevOdometer != nil {
odometer := log.Odometer
distance := odometer - *prevOdometer
if distance > 0 {
// Verbrauch = Liter / km * 100
consumption := (log.Quantity / distance) * 100
unit := "L"
if prevUnit != nil && *prevUnit != "" {
unit = *prevUnit
} else if log.Unit != nil && *log.Unit != "" {
unit = *log.Unit
}
val := fmt.Sprintf("%.2f %s/100km", consumption, unit)
log.ConsumptionPer100Km = &val
}
}
// Odometer und Einheit merken für nächste Tankung
if log.Odometer > 0 {
prevOdometer = &log.Odometer
}
if log.Unit != nil && *log.Unit != "" {
prevUnit = log.Unit
}
}
}
}
// GetConsumption berechnet den Kraftstoffverbrauch für ein Fahrzeug über einen Zeitraum.
func GetConsumption(db *sql.DB, vehicleID int, dateFrom, dateTo *string) (*ConsumptionResult, error) {
result := &ConsumptionResult{
VehicleID: vehicleID,
}
// Fahrzeugname und Kraftstoff holen
var fuelName, fuelUnit string
var fuelID *int
err := db.QueryRow(`
SELECT v.name, f.name, f.unit, v.fuel_id
FROM vehicles v
LEFT JOIN fuels f ON v.fuel_id = f.id
WHERE v.id = ?
`, vehicleID).Scan(&result.VehicleName, &fuelName, &fuelUnit, &fuelID)
if err != nil {
return nil, err
}
if fuelName != "" {
result.FuelName = &fuelName
}
if fuelUnit != "" {
result.FuelUnit = &fuelUnit
}
// Zeitraum setzen
if dateFrom != nil {
result.PeriodFrom = dateFrom
}
if dateTo != nil {
result.PeriodTo = dateTo
}
// Verbrauchseinheit bestimmen
unit := "L"
if result.FuelUnit != nil {
unit = *result.FuelUnit
}
result.ConsumptionUnit = fmt.Sprintf("%s/100km", unit)
// Tankungseinträge ermitteln
var dateFromClause, dateToClause string
var dateArgs []interface{}
if dateFrom != nil {
dateFromClause = "AND l.datetime >= ?"
dateArgs = append(dateArgs, *dateFrom)
}
if dateTo != nil {
dateToClause = "AND l.datetime <= ?"
dateArgs = append(dateArgs, *dateTo)
}
// Alle Tankungen abrufen (geordnet nach Odometer)
query := fmt.Sprintf(`
SELECT l.odometer, l.quantity, l.datetime
FROM logs l
WHERE l.vehicle_id = ? AND l.log_type = 'tankung'
%s%s
ORDER BY l.odometer ASC
`, dateFromClause, dateToClause)
dateArgs = append([]interface{}{vehicleID}, dateArgs...)
rows, err := db.Query(query, dateArgs...)
if err != nil {
return nil, err
}
defer rows.Close()
type tanking struct {
odometer float64
quantity float64
}
var tankings []tanking
for rows.Next() {
var t tanking
var datetime string
if err := rows.Scan(&t.odometer, &t.quantity, &datetime); err != nil {
return nil, err
}
tankings = append(tankings, t)
_ = datetime
}
if err := rows.Err(); err != nil {
return nil, err
}
// Mindestens 2 Tankungen für Verbrauchsberechnung
if len(tankings) < 2 {
var zero float64
result.AverageConsumption = &zero
return result, nil
}
// Gesamtstrecke: letzte - erste Tankung
result.TotalDistance = tankings[len(tankings)-1].odometer - tankings[0].odometer
// Gesamtverbrauch: Summe aller Tankungen AUSSER der ersten
// (die erste füllt nur den Rest im Tank, kein vollständiger Verbrauch)
for i := 1; i < len(tankings); i++ {
result.TotalFuel += tankings[i].quantity
}
// Durchschnittsverbrauch berechnen (Liter pro 100km)
if result.TotalDistance > 0 {
avg := (result.TotalFuel / result.TotalDistance) * 100
result.AverageConsumption = &avg
}
return result, nil
}
+1
View File
@@ -0,0 +1 @@
package model
+1
View File
@@ -0,0 +1 @@
package model
+204
View File
@@ -0,0 +1,204 @@
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
}