Initial commit: gocarlog project — Milestones 1-10 completed

This commit is contained in:
2026-06-07 11:57:42 +02:00
commit 1d17422093
29 changed files with 4532 additions and 0 deletions
+53
View File
@@ -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,
})
}
+30
View File
@@ -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,
})
}
+146
View File
@@ -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,
})
}
+296
View File
@@ -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
}