Files

297 lines
6.6 KiB
Go

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
}