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(¤tOdometer) 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 }