297 lines
6.6 KiB
Go
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
|
|
}
|