399 lines
11 KiB
Go
399 lines
11 KiB
Go
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
|
|
}
|