Initial commit: gocarlog project — Milestones 1-10 completed
This commit is contained in:
@@ -0,0 +1,101 @@
|
||||
package db
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"fmt"
|
||||
"log"
|
||||
"strings"
|
||||
|
||||
_ "embed"
|
||||
_ "github.com/mattn/go-sqlite3"
|
||||
)
|
||||
|
||||
//go:embed migration.sql
|
||||
var migrationSQL string
|
||||
|
||||
// Database holds the database connection and provides common methods.
|
||||
type Database struct {
|
||||
*sql.DB
|
||||
}
|
||||
|
||||
// NewDatabase opens a SQLite database at the given path, runs migrations,
|
||||
// and seeds the fuel table if empty.
|
||||
func NewDatabase(path string) (*Database, error) {
|
||||
sqlDB, err := sql.Open("sqlite3", path)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Enable Foreign Keys (SQLite requires this per-connection)
|
||||
if _, err := sqlDB.Exec("PRAGMA foreign_keys = ON"); err != nil {
|
||||
sqlDB.Close()
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Run migrations
|
||||
if err := RunMigrations(sqlDB); err != nil {
|
||||
sqlDB.Close()
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Seed fuels
|
||||
tx, err := sqlDB.Begin()
|
||||
if err != nil {
|
||||
sqlDB.Close()
|
||||
return nil, err
|
||||
}
|
||||
if err := SeedFuelTypes(tx); err != nil {
|
||||
tx.Rollback()
|
||||
sqlDB.Close()
|
||||
return nil, err
|
||||
}
|
||||
if err := tx.Commit(); err != nil {
|
||||
sqlDB.Close()
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return &Database{DB: sqlDB}, nil
|
||||
}
|
||||
|
||||
// New creates a new Database instance from an existing sql.DB.
|
||||
func New(db *sql.DB) *Database {
|
||||
return &Database{DB: db}
|
||||
}
|
||||
|
||||
// RunMigrations applies the embedded migration SQL to the database.
|
||||
func RunMigrations(db *sql.DB) error {
|
||||
// Split by ; but handle multi-line statements that may start with --
|
||||
lines := strings.Split(migrationSQL, "\n")
|
||||
var stmtBuilder strings.Builder
|
||||
for _, line := range lines {
|
||||
trimmed := strings.TrimSpace(line)
|
||||
// Skip pure comment lines
|
||||
if strings.HasPrefix(trimmed, "--") {
|
||||
continue
|
||||
}
|
||||
stmtBuilder.WriteString(line)
|
||||
stmtBuilder.WriteString("\n")
|
||||
}
|
||||
fullSQL := stmtBuilder.String()
|
||||
|
||||
// Split into individual statements
|
||||
rawStmts := strings.Split(fullSQL, ";")
|
||||
count := 0
|
||||
for _, raw := range rawStmts {
|
||||
stmt := strings.TrimSpace(raw)
|
||||
if stmt == "" {
|
||||
continue
|
||||
}
|
||||
count++
|
||||
display := stmt
|
||||
if len(display) > 80 {
|
||||
display = display[:80] + "..."
|
||||
}
|
||||
log.Printf(" [%d] %s", count, display)
|
||||
if _, err := db.Exec(stmt); err != nil {
|
||||
return fmt.Errorf("exec migration stmt %d: %w", count, err)
|
||||
}
|
||||
}
|
||||
log.Printf("Migrations completed successfully (%d statements)", count)
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
-- Fuel Types
|
||||
CREATE TABLE IF NOT EXISTS fuels (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
name VARCHAR(50) NOT NULL UNIQUE,
|
||||
unit VARCHAR(10) NOT NULL
|
||||
);
|
||||
|
||||
-- Vehicles
|
||||
CREATE TABLE IF NOT EXISTS vehicles (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
name VARCHAR(100) NOT NULL,
|
||||
manufacturer VARCHAR(100),
|
||||
model VARCHAR(100),
|
||||
fuel_id INTEGER,
|
||||
year INTEGER,
|
||||
description TEXT,
|
||||
purchase_date DATE,
|
||||
license_plate VARCHAR(20),
|
||||
weight_kg REAL,
|
||||
power_kw REAL,
|
||||
max_odometer REAL,
|
||||
current_odometer REAL DEFAULT 0,
|
||||
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
|
||||
updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
|
||||
FOREIGN KEY (fuel_id) REFERENCES fuels(id)
|
||||
);
|
||||
|
||||
-- Logbook
|
||||
CREATE TABLE IF NOT EXISTS logs (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
vehicle_id INTEGER NOT NULL,
|
||||
fuel_id INTEGER,
|
||||
log_type VARCHAR(20) NOT NULL,
|
||||
odometer REAL,
|
||||
datetime DATETIME NOT NULL,
|
||||
cost REAL,
|
||||
quantity REAL,
|
||||
unit VARCHAR(10),
|
||||
note TEXT,
|
||||
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
|
||||
FOREIGN KEY (vehicle_id) REFERENCES vehicles(id),
|
||||
FOREIGN KEY (fuel_id) REFERENCES fuels(id)
|
||||
);
|
||||
@@ -0,0 +1,38 @@
|
||||
package db
|
||||
|
||||
import "database/sql"
|
||||
|
||||
// FuelType definiert einen verfügbaren Kraftstofftyp.
|
||||
type FuelType struct {
|
||||
ID int
|
||||
Name string
|
||||
Unit string
|
||||
}
|
||||
|
||||
// DefaultFuelTypes enthält die standardmäßigen Kraftstofftypen,
|
||||
// wie sie in der Migration-Datei definiert sind.
|
||||
var DefaultFuelTypes = []FuelType{
|
||||
{ID: 0, Name: "Diesel", Unit: "L"},
|
||||
{ID: 1, Name: "Benzin", Unit: "L"},
|
||||
{ID: 2, Name: "LPG", Unit: "L"},
|
||||
{ID: 3, Name: "CNG", Unit: "L"},
|
||||
{ID: 4, Name: "Strom", Unit: "kWh"},
|
||||
}
|
||||
|
||||
// SeedFuelTypes fügt die standardmäßigen Kraftstofftypen in die Datenbank ein,
|
||||
// falls sie noch nicht existieren (INSERT OR IGNORE).
|
||||
//
|
||||
// Diese Funktion wird automatisch beim Init() aufgerufen,
|
||||
// ist aber auch separat verfügbar, um z. B. in Tests
|
||||
// einen bekannten Seed-State zu setzen.
|
||||
func SeedFuelTypes(tx *sql.Tx) error {
|
||||
for _, fuel := range DefaultFuelTypes {
|
||||
if _, err := tx.Exec(
|
||||
"INSERT OR IGNORE INTO fuels (id, name, unit) VALUES (?, ?, ?)",
|
||||
fuel.ID, fuel.Name, fuel.Unit,
|
||||
); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"log"
|
||||
"net/http"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"gocarlog/internal/middleware"
|
||||
"gocarlog/internal/model"
|
||||
)
|
||||
|
||||
// HandleConsumption handles GET /api/vehicles/:id/consumption
|
||||
func HandleConsumption(w http.ResponseWriter, r *http.Request) {
|
||||
// Extract ID from URL path: /api/vehicles/:id/consumption
|
||||
parts := strings.Split(strings.Trim(r.URL.Path, "/"), "/")
|
||||
// parts: ["api", "vehicles", ":id", "consumption"]
|
||||
if len(parts) < 4 {
|
||||
middleware.WriteError(w, http.StatusBadRequest, "invalid path")
|
||||
return
|
||||
}
|
||||
|
||||
id, err := strconv.Atoi(parts[2])
|
||||
if err != nil {
|
||||
middleware.WriteError(w, http.StatusBadRequest, "invalid vehicle ID")
|
||||
return
|
||||
}
|
||||
|
||||
dateFrom := r.URL.Query().Get("date_from")
|
||||
dateTo := r.URL.Query().Get("date_to")
|
||||
|
||||
var dateFromPtr, dateToPtr *string
|
||||
if dateFrom != "" {
|
||||
dateFromPtr = &dateFrom
|
||||
}
|
||||
if dateTo != "" {
|
||||
dateToPtr = &dateTo
|
||||
}
|
||||
|
||||
db := r.Context().Value(middleware.DbKey).(*sql.DB)
|
||||
result, err := model.GetConsumption(db, id, dateFromPtr, dateToPtr)
|
||||
if err != nil {
|
||||
log.Printf("error getting consumption: %v", err)
|
||||
middleware.WriteError(w, http.StatusInternalServerError, "failed to get consumption data")
|
||||
return
|
||||
}
|
||||
|
||||
middleware.WriteJSON(w, http.StatusOK, map[string]interface{}{
|
||||
"success": true,
|
||||
"data": result,
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"log"
|
||||
"net/http"
|
||||
|
||||
"gocarlog/internal/middleware"
|
||||
"gocarlog/internal/model"
|
||||
)
|
||||
|
||||
// HandleListFuels handles GET /fuels
|
||||
func HandleListFuels(w http.ResponseWriter, r *http.Request) {
|
||||
db := r.Context().Value(middleware.DbKey).(*sql.DB)
|
||||
fuels, err := model.GetFuels(db)
|
||||
if err != nil {
|
||||
log.Printf("error listing fuels: %v", err)
|
||||
middleware.WriteError(w, http.StatusInternalServerError, "failed to list fuels")
|
||||
return
|
||||
}
|
||||
|
||||
if fuels == nil {
|
||||
fuels = []model.Fuel{}
|
||||
}
|
||||
|
||||
middleware.WriteJSON(w, http.StatusOK, map[string]interface{}{
|
||||
"success": true,
|
||||
"data": fuels,
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,146 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"log"
|
||||
"net/http"
|
||||
"strconv"
|
||||
|
||||
"gocarlog/internal/middleware"
|
||||
"gocarlog/internal/model"
|
||||
)
|
||||
|
||||
// HandleCreateLog handles POST /logs
|
||||
func HandleCreateLog(w http.ResponseWriter, r *http.Request) {
|
||||
// flexibleLog nimmt alle Werte als String entgegen und konvertiert später
|
||||
type flexibleLog struct {
|
||||
VehicleID string `json:"vehicle_id"`
|
||||
FuelID *string `json:"fuel_id,omitempty"`
|
||||
LogType string `json:"log_type"`
|
||||
Odometer string `json:"odometer"`
|
||||
Datetime string `json:"datetime"`
|
||||
Cost string `json:"cost"`
|
||||
Quantity string `json:"quantity"`
|
||||
Unit *string `json:"unit,omitempty"`
|
||||
Note *string `json:"note,omitempty"`
|
||||
}
|
||||
|
||||
var fl flexibleLog
|
||||
if err := json.NewDecoder(r.Body).Decode(&fl); err != nil {
|
||||
middleware.WriteError(w, http.StatusBadRequest, "invalid JSON body")
|
||||
return
|
||||
}
|
||||
|
||||
// Validate required fields
|
||||
if fl.VehicleID == "" || fl.LogType == "" {
|
||||
middleware.WriteError(w, http.StatusBadRequest, "vehicle_id and log_type are required")
|
||||
return
|
||||
}
|
||||
|
||||
vehicleID, err := strconv.Atoi(fl.VehicleID)
|
||||
if err != nil {
|
||||
middleware.WriteError(w, http.StatusBadRequest, "invalid vehicle_id")
|
||||
return
|
||||
}
|
||||
|
||||
// Convert to model.Log
|
||||
var fuelID *int
|
||||
if fl.FuelID != nil && *fl.FuelID != "" {
|
||||
fid, e := strconv.Atoi(*fl.FuelID)
|
||||
if e == nil {
|
||||
fuelID = &fid
|
||||
}
|
||||
}
|
||||
|
||||
l := &model.Log{
|
||||
VehicleID: vehicleID,
|
||||
FuelID: fuelID,
|
||||
LogType: fl.LogType,
|
||||
Odometer: parseFloat(fl.Odometer),
|
||||
Datetime: fl.Datetime,
|
||||
Cost: parseFloat(fl.Cost),
|
||||
Quantity: parseFloat(fl.Quantity),
|
||||
Unit: fl.Unit,
|
||||
Note: fl.Note,
|
||||
}
|
||||
|
||||
// Set defaults
|
||||
if l.Datetime == "" {
|
||||
l.Datetime = "CURRENT_TIMESTAMP"
|
||||
}
|
||||
if l.Note == nil {
|
||||
n := ""
|
||||
l.Note = &n
|
||||
}
|
||||
|
||||
if err := model.CreateLog(r.Context().Value(middleware.DbKey).(*sql.DB), l); err != nil {
|
||||
log.Printf("error creating log: %v", err)
|
||||
middleware.WriteError(w, http.StatusInternalServerError, "failed to create log")
|
||||
return
|
||||
}
|
||||
|
||||
middleware.WriteJSON(w, http.StatusCreated, map[string]interface{}{
|
||||
"success": true,
|
||||
"data": l,
|
||||
})
|
||||
}
|
||||
|
||||
func parseFloat(s string) float64 {
|
||||
v, err := strconv.ParseFloat(s, 64)
|
||||
if err != nil {
|
||||
return 0
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
||||
// HandleListLogs handles GET /logs
|
||||
func HandleListLogs(w http.ResponseWriter, r *http.Request) {
|
||||
filters := map[string]string{}
|
||||
|
||||
if v := r.URL.Query().Get("vehicle_id"); v != "" {
|
||||
filters["vehicle_id"] = v
|
||||
}
|
||||
if v := r.URL.Query().Get("log_type"); v != "" {
|
||||
filters["log_type"] = v
|
||||
}
|
||||
if v := r.URL.Query().Get("date_from"); v != "" {
|
||||
filters["date_from"] = v
|
||||
}
|
||||
if v := r.URL.Query().Get("date_to"); v != "" {
|
||||
filters["date_to"] = v
|
||||
}
|
||||
|
||||
limit := 50
|
||||
if limitStr := r.URL.Query().Get("limit"); limitStr != "" {
|
||||
if l, err := strconv.Atoi(limitStr); err == nil && l > 0 {
|
||||
limit = l
|
||||
}
|
||||
}
|
||||
|
||||
offset := 0
|
||||
if offsetStr := r.URL.Query().Get("offset"); offsetStr != "" {
|
||||
if o, err := strconv.Atoi(offsetStr); err == nil && o >= 0 {
|
||||
offset = o
|
||||
}
|
||||
}
|
||||
|
||||
db := r.Context().Value(middleware.DbKey).(*sql.DB)
|
||||
logs, total, costSummary, err := model.GetLogs(db, filters, limit, offset)
|
||||
if err != nil {
|
||||
log.Printf("error listing logs: %v", err)
|
||||
middleware.WriteError(w, http.StatusInternalServerError, "failed to list logs")
|
||||
return
|
||||
}
|
||||
|
||||
if logs == nil {
|
||||
logs = []model.LogWithVehicle{}
|
||||
}
|
||||
|
||||
middleware.WriteJSON(w, http.StatusOK, map[string]interface{}{
|
||||
"success": true,
|
||||
"data": logs,
|
||||
"total": total,
|
||||
"cost_summary": costSummary,
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,296 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"log"
|
||||
"net/http"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"gocarlog/internal/middleware"
|
||||
"gocarlog/internal/model"
|
||||
)
|
||||
|
||||
// createVehicleReq nimmt flexible JSON-Daten entgegen: Strings und Zahlen
|
||||
type createVehicleReq struct {
|
||||
Name string `json:"name"`
|
||||
Manufacturer any `json:"manufacturer"`
|
||||
Model any `json:"model"`
|
||||
Year any `json:"year"`
|
||||
Description any `json:"description"`
|
||||
LicensePlate any `json:"license_plate"`
|
||||
Plate any `json:"plate"`
|
||||
PurchaseDate any `json:"purchase_date"`
|
||||
WeightKg any `json:"weight"`
|
||||
PowerKw any `json:"power"`
|
||||
Power any `json:"power_kw"`
|
||||
MaxOdometer any `json:"max_odometer"`
|
||||
CurrentOdometer any `json:"current_odometer"`
|
||||
FuelID any `json:"fuel_id"`
|
||||
}
|
||||
|
||||
// anyToStr konvertiert any → *string (nil, "", "", 0 → nil)
|
||||
func anyToStr(v any) *string {
|
||||
if v == nil {
|
||||
return nil
|
||||
}
|
||||
switch s := v.(type) {
|
||||
case string:
|
||||
if s == "" {
|
||||
return nil
|
||||
}
|
||||
return &s
|
||||
case float64:
|
||||
if s == 0 {
|
||||
return nil
|
||||
}
|
||||
str := strconv.FormatFloat(s, 'f', -1, 64)
|
||||
if str == "0" {
|
||||
return nil
|
||||
}
|
||||
return &str
|
||||
case bool:
|
||||
b := strconv.FormatBool(s)
|
||||
return &b
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
// anyToInt konvertiert any → *int
|
||||
func anyToInt(v any) *int {
|
||||
if v == nil {
|
||||
return nil
|
||||
}
|
||||
switch s := v.(type) {
|
||||
case string:
|
||||
if s == "" {
|
||||
return nil
|
||||
}
|
||||
i, err := strconv.Atoi(s)
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
return &i
|
||||
case float64:
|
||||
i := int(s)
|
||||
return &i
|
||||
case bool:
|
||||
b := 0
|
||||
if s {
|
||||
b = 1
|
||||
}
|
||||
return &b
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
// anyToFloat konvertiert any → *float64
|
||||
func anyToFloat(v any) *float64 {
|
||||
if v == nil {
|
||||
return nil
|
||||
}
|
||||
switch s := v.(type) {
|
||||
case string:
|
||||
if s == "" {
|
||||
return nil
|
||||
}
|
||||
f, err := strconv.ParseFloat(s, 64)
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
return &f
|
||||
case float64:
|
||||
if s == 0 {
|
||||
return nil
|
||||
}
|
||||
return &s
|
||||
case bool:
|
||||
f := 0.0
|
||||
if s {
|
||||
f = 1.0
|
||||
}
|
||||
return &f
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
// anyToFloat64 konvertiert any → float64 (0 wenn leer)
|
||||
func anyToFloat64(v any) float64 {
|
||||
if f := anyToFloat(v); f != nil {
|
||||
return *f
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
// HandleCreateVehicle handles POST /vehicles
|
||||
func HandleCreateVehicle(w http.ResponseWriter, r *http.Request) {
|
||||
var req createVehicleReq
|
||||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||||
middleware.WriteError(w, http.StatusBadRequest, "invalid JSON body")
|
||||
return
|
||||
}
|
||||
|
||||
// Validate required fields
|
||||
if req.Name == "" {
|
||||
middleware.WriteError(w, http.StatusBadRequest, "name is required")
|
||||
return
|
||||
}
|
||||
|
||||
// license_plate: priorisiere plate (Frontend), fallback auf license_plate
|
||||
var licensePlate *string
|
||||
if str := anyToStr(req.Plate); str != nil {
|
||||
licensePlate = str
|
||||
} else {
|
||||
licensePlate = anyToStr(req.LicensePlate)
|
||||
}
|
||||
|
||||
// power: priorisiere power (Frontend), fallback auf power_kw
|
||||
var powerKw *float64
|
||||
if f := anyToFloat(req.Power); f != nil {
|
||||
powerKw = f
|
||||
} else {
|
||||
powerKw = anyToFloat(req.PowerKw)
|
||||
}
|
||||
|
||||
if req.FuelID == nil || anyToInt(req.FuelID) == nil {
|
||||
middleware.WriteError(w, http.StatusBadRequest, "fuel_id is required")
|
||||
return
|
||||
}
|
||||
fuelID := anyToInt(req.FuelID)
|
||||
if fuelID == nil {
|
||||
middleware.WriteError(w, http.StatusBadRequest, "invalid fuel_id")
|
||||
return
|
||||
}
|
||||
|
||||
// Convert to model.Vehicle
|
||||
v := &model.Vehicle{
|
||||
Name: req.Name,
|
||||
FuelID: fuelID,
|
||||
Manufacturer: anyToStr(req.Manufacturer),
|
||||
Model: anyToStr(req.Model),
|
||||
Year: anyToInt(req.Year),
|
||||
Description: anyToStr(req.Description),
|
||||
LicensePlate: licensePlate,
|
||||
PurchaseDate: anyToStr(req.PurchaseDate),
|
||||
WeightKg: anyToFloat(req.WeightKg),
|
||||
PowerKw: powerKw,
|
||||
CurrentOdometer: anyToFloat64(req.CurrentOdometer),
|
||||
MaxOdometer: anyToFloat(req.MaxOdometer),
|
||||
}
|
||||
|
||||
if err := model.CreateVehicle(r.Context().Value(middleware.DbKey).(*sql.DB), v); err != nil {
|
||||
log.Printf("error creating vehicle: %v", err)
|
||||
middleware.WriteError(w, http.StatusInternalServerError, "failed to create vehicle")
|
||||
return
|
||||
}
|
||||
|
||||
middleware.WriteJSON(w, http.StatusCreated, map[string]interface{}{
|
||||
"success": true,
|
||||
"data": v,
|
||||
})
|
||||
}
|
||||
|
||||
// HandleListVehicles handles GET /vehicles
|
||||
func HandleListVehicles(w http.ResponseWriter, r *http.Request) {
|
||||
filters := map[string]string{}
|
||||
|
||||
if v := r.URL.Query().Get("name"); v != "" {
|
||||
filters["name"] = v
|
||||
}
|
||||
if v := r.URL.Query().Get("license_plate"); v != "" {
|
||||
filters["license_plate"] = v
|
||||
}
|
||||
if v := r.URL.Query().Get("fuel_id"); v != "" {
|
||||
filters["fuel_id"] = v
|
||||
}
|
||||
if v := r.URL.Query().Get("manufacturer"); v != "" {
|
||||
filters["manufacturer"] = v
|
||||
}
|
||||
if v := r.URL.Query().Get("model"); v != "" {
|
||||
filters["model"] = v
|
||||
}
|
||||
if v := r.URL.Query().Get("year"); v != "" {
|
||||
filters["year"] = v
|
||||
}
|
||||
|
||||
limit := 50
|
||||
if limitStr := r.URL.Query().Get("limit"); limitStr != "" {
|
||||
if l, err := strconv.Atoi(limitStr); err == nil && l > 0 {
|
||||
limit = l
|
||||
}
|
||||
}
|
||||
|
||||
offset := 0
|
||||
if offsetStr := r.URL.Query().Get("offset"); offsetStr != "" {
|
||||
if o, err := strconv.Atoi(offsetStr); err == nil && o >= 0 {
|
||||
offset = o
|
||||
}
|
||||
}
|
||||
|
||||
db := r.Context().Value(middleware.DbKey).(*sql.DB)
|
||||
vehicles, total, err := model.GetVehicles(db, filters, limit, offset)
|
||||
if err != nil {
|
||||
log.Printf("error listing vehicles: %v", err)
|
||||
middleware.WriteError(w, http.StatusInternalServerError, "failed to list vehicles")
|
||||
return
|
||||
}
|
||||
|
||||
if vehicles == nil {
|
||||
vehicles = []model.VehicleListEntry{}
|
||||
}
|
||||
|
||||
middleware.WriteJSON(w, http.StatusOK, map[string]interface{}{
|
||||
"data": vehicles,
|
||||
"total": total,
|
||||
})
|
||||
}
|
||||
|
||||
// HandleGetVehicle handles GET /vehicles/:id
|
||||
func HandleGetVehicle(w http.ResponseWriter, r *http.Request) {
|
||||
id, err := extractID(r)
|
||||
if err != nil {
|
||||
middleware.WriteError(w, http.StatusBadRequest, "invalid vehicle ID")
|
||||
return
|
||||
}
|
||||
|
||||
db := r.Context().Value(middleware.DbKey).(*sql.DB)
|
||||
vehicle, err := model.GetVehicleByID(db, id)
|
||||
if err != nil {
|
||||
if err == sql.ErrNoRows {
|
||||
middleware.WriteError(w, http.StatusNotFound, "vehicle not found")
|
||||
return
|
||||
}
|
||||
log.Printf("error getting vehicle: %v", err)
|
||||
middleware.WriteError(w, http.StatusInternalServerError, "failed to get vehicle")
|
||||
return
|
||||
}
|
||||
|
||||
if vehicle == nil {
|
||||
middleware.WriteError(w, http.StatusNotFound, "vehicle not found")
|
||||
return
|
||||
}
|
||||
|
||||
middleware.WriteJSON(w, http.StatusOK, map[string]interface{}{
|
||||
"success": true,
|
||||
"data": vehicle,
|
||||
})
|
||||
}
|
||||
|
||||
// extractID extracts an integer ID from the URL path after the last slash.
|
||||
func extractID(r *http.Request) (int, error) {
|
||||
path := r.URL.Path
|
||||
lastSlash := strings.LastIndex(path, "/")
|
||||
if lastSlash == -1 {
|
||||
return 0, nil
|
||||
}
|
||||
idStr := path[lastSlash+1:]
|
||||
id, err := strconv.Atoi(idStr)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return id, nil
|
||||
}
|
||||
@@ -0,0 +1,95 @@
|
||||
package middleware
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"log"
|
||||
"net/http"
|
||||
"time"
|
||||
)
|
||||
|
||||
// middlewareKey is a custom type for context keys to avoid collisions.
|
||||
type middlewareKey string
|
||||
|
||||
// DbKey is the context key for the database connection.
|
||||
// Handlers use this to retrieve the *sql.DB from the request context.
|
||||
var DbKey middlewareKey = "db"
|
||||
|
||||
// WithDB wraps a handler to inject the database into the request context.
|
||||
func WithDB(db *sql.DB) func(http.Handler) http.Handler {
|
||||
return func(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
ctx := context.WithValue(r.Context(), DbKey, db)
|
||||
r = r.WithContext(ctx)
|
||||
next.ServeHTTP(w, r)
|
||||
})
|
||||
}
|
||||
}
|
||||
// Logging returns a middleware that logs HTTP request details.
|
||||
func Logging(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
start := time.Now()
|
||||
|
||||
// Wrap the ResponseWriter to capture the status code
|
||||
wrapped := &statusResponseWriter{ResponseWriter: w, statusCode: http.StatusOK}
|
||||
|
||||
next.ServeHTTP(wrapped, r)
|
||||
|
||||
duration := time.Since(start)
|
||||
log.Printf("[%s] %s %s %d %v",
|
||||
r.Method,
|
||||
r.URL.Path,
|
||||
time.Now().Format("2006-01-02T15:04:05"),
|
||||
wrapped.statusCode,
|
||||
duration,
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
// CORS returns a middleware that adds CORS headers to all responses.
|
||||
func CORS(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Access-Control-Allow-Origin", "*")
|
||||
w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
|
||||
w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
|
||||
w.Header().Set("Access-Control-Max-Age", "86400")
|
||||
|
||||
// Handle preflight OPTIONS requests
|
||||
if r.Method == "OPTIONS" {
|
||||
w.WriteHeader(http.StatusOK)
|
||||
return
|
||||
}
|
||||
|
||||
next.ServeHTTP(w, r)
|
||||
})
|
||||
}
|
||||
|
||||
// WriteJSON writes a JSON response with the given status code.
|
||||
func WriteJSON(w http.ResponseWriter, status int, data interface{}) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(status)
|
||||
if err := json.NewEncoder(w).Encode(data); err != nil {
|
||||
log.Printf("error encoding JSON response: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// WriteError writes a JSON error response with the given status code.
|
||||
func WriteError(w http.ResponseWriter, status int, message string) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(status)
|
||||
json.NewEncoder(w).Encode(map[string]string{
|
||||
"error": message,
|
||||
})
|
||||
}
|
||||
|
||||
// statusResponseWriter wraps http.ResponseWriter to capture the status code.
|
||||
type statusResponseWriter struct {
|
||||
http.ResponseWriter
|
||||
statusCode int
|
||||
}
|
||||
|
||||
func (sw *statusResponseWriter) WriteHeader(code int) {
|
||||
sw.statusCode = code
|
||||
sw.ResponseWriter.WriteHeader(code)
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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(¤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
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
package model
|
||||
@@ -0,0 +1 @@
|
||||
package model
|
||||
@@ -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
|
||||
}
|
||||
@@ -0,0 +1,121 @@
|
||||
package router
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net/http"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"gocarlog/internal/handler"
|
||||
"gocarlog/internal/middleware"
|
||||
|
||||
"gocarlog/internal/db"
|
||||
)
|
||||
|
||||
// ParamKey is used to store path parameters in the request context.
|
||||
type ParamKey struct{}
|
||||
|
||||
// New creates and configures the HTTP router with all API routes.
|
||||
func New(database *db.Database) http.Handler {
|
||||
// Use a custom multiplexer since Go 1.19 ServeMux doesn't support
|
||||
// method routing or path parameters (e.g., /vehicles/:id).
|
||||
mux := &patternMux{}
|
||||
|
||||
// --- Fuel endpoints ---
|
||||
mux.HandleFunc("GET", "/api/fuels", handler.HandleListFuels)
|
||||
|
||||
// --- Vehicle endpoints ---
|
||||
mux.HandleFunc("POST", "/api/vehicles", handler.HandleCreateVehicle)
|
||||
mux.HandleFunc("GET", "/api/vehicles", handler.HandleListVehicles)
|
||||
// GET /api/vehicles/:id/consumption must be registered before the generic catch-all
|
||||
mux.HandleFunc("GET", "/api/vehicles/:id/consumption", handler.HandleConsumption)
|
||||
mux.HandleFunc("GET", "/api/vehicles/:id", handler.HandleGetVehicle)
|
||||
|
||||
// --- Log endpoints ---
|
||||
mux.HandleFunc("POST", "/api/logs", handler.HandleCreateLog)
|
||||
mux.HandleFunc("GET", "/api/logs", handler.HandleListLogs)
|
||||
|
||||
// --- Apply middleware chain ---
|
||||
// Order: CORS -> Logging -> WithDB -> mux
|
||||
var h http.Handler
|
||||
h = mux
|
||||
h = middleware.Logging(h)
|
||||
h = middleware.CORS(h)
|
||||
h = middleware.WithDB(database.DB)(h)
|
||||
|
||||
return h
|
||||
}
|
||||
|
||||
// patternMux is a simple multiplexer that supports method-based routing
|
||||
// and path parameters (e.g. :id) for Go 1.19 compatibility.
|
||||
type patternMux struct {
|
||||
routes []route
|
||||
}
|
||||
|
||||
type route struct {
|
||||
method string
|
||||
pattern string
|
||||
handler http.HandlerFunc
|
||||
}
|
||||
|
||||
func (m *patternMux) HandleFunc(method, pattern string, handler http.HandlerFunc) {
|
||||
m.routes = append(m.routes, route{method: method, pattern: pattern, handler: handler})
|
||||
}
|
||||
|
||||
func (m *patternMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
||||
handler, params := m.match(r.Method, r.URL.Path)
|
||||
if handler == nil {
|
||||
http.NotFound(w, r)
|
||||
return
|
||||
}
|
||||
|
||||
// Attach captured path parameters to context as int values
|
||||
if len(params) > 0 {
|
||||
intParams := make(map[string]int)
|
||||
for key, val := range params {
|
||||
if v, err := strconv.Atoi(val); err == nil {
|
||||
intParams[key] = v
|
||||
}
|
||||
}
|
||||
ctx := context.WithValue(r.Context(), ParamKey{}, intParams)
|
||||
r = r.WithContext(ctx)
|
||||
}
|
||||
|
||||
handler(w, r)
|
||||
}
|
||||
|
||||
// match tries to match the request against registered routes.
|
||||
func (m *patternMux) match(method, path string) (http.HandlerFunc, map[string]string) {
|
||||
for _, r := range m.routes {
|
||||
if r.method != method {
|
||||
continue
|
||||
}
|
||||
if params := matchPattern(r.pattern, path); params != nil {
|
||||
return r.handler, params
|
||||
}
|
||||
}
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
// matchPattern matches a pattern like /api/v1/vehicles/:id/consumption against a path.
|
||||
// Returns nil if no match, otherwise a map of captured parameters (as strings).
|
||||
func matchPattern(pattern, path string) map[string]string {
|
||||
pParts := strings.Split(strings.Trim(pattern, "/"), "/")
|
||||
aParts := strings.Split(strings.Trim(path, "/"), "/")
|
||||
|
||||
if len(pParts) != len(aParts) {
|
||||
return nil
|
||||
}
|
||||
|
||||
params := make(map[string]string)
|
||||
for i := range pParts {
|
||||
p := pParts[i]
|
||||
a := aParts[i]
|
||||
if strings.HasPrefix(p, ":") {
|
||||
params[p[1:]] = a
|
||||
} else if p != a {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
return params
|
||||
}
|
||||
Reference in New Issue
Block a user