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 }