chore: add ansible backend docker frontend-prep
This commit is contained in:
@@ -0,0 +1,624 @@
|
||||
// ============================================
|
||||
// handlers/traffic_handlers.go - COMPLET
|
||||
// ============================================
|
||||
|
||||
package handlers
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"gestion/db"
|
||||
"gestion/models"
|
||||
"gestion/services"
|
||||
"io"
|
||||
"log"
|
||||
"math"
|
||||
"net/http"
|
||||
"os"
|
||||
"strconv"
|
||||
"time"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
)
|
||||
|
||||
// ============================================
|
||||
// INCIDENTS TRAFFIC TOMTOM
|
||||
// ============================================
|
||||
|
||||
// GetIncidentsAroundDeliveryPerson récupère les incidents autour d'un livreur
|
||||
// GET /api/v2/admin/traffic/delivery/:username/incidents
|
||||
func GetIncidentsAroundDeliveryPerson(c *gin.Context) {
|
||||
database := c.MustGet("database").(*db.Database)
|
||||
|
||||
userRole := c.GetString("role")
|
||||
if userRole != "admin" && userRole != "livreur" {
|
||||
c.JSON(http.StatusForbidden, gin.H{"error": "Accès refusé"})
|
||||
return
|
||||
}
|
||||
|
||||
username := c.Param("username")
|
||||
if username == "" {
|
||||
c.JSON(http.StatusBadRequest, gin.H{"error": "Username requis"})
|
||||
return
|
||||
}
|
||||
|
||||
// Récupérer position du livreur
|
||||
lat, lon, err := database.GetDeliveryPersonLocation(username)
|
||||
if err != nil {
|
||||
c.JSON(http.StatusNotFound, gin.H{
|
||||
"error": "Position livreur non trouvée",
|
||||
"details": err.Error(),
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
// Rayon de recherche par défaut: 5 km
|
||||
radius := 5000 // mètres
|
||||
|
||||
// Récupérer incidents TomTom
|
||||
incidents, err := fetchIncidents(lat, lon, radius)
|
||||
if err != nil {
|
||||
c.JSON(http.StatusInternalServerError, gin.H{
|
||||
"error": "Erreur récupération incidents",
|
||||
"details": err.Error(),
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
c.JSON(http.StatusOK, gin.H{
|
||||
"success": true,
|
||||
"username": username,
|
||||
"location": gin.H{"latitude": lat, "longitude": lon},
|
||||
"radius_km": radius / 1000,
|
||||
"incidents": incidents,
|
||||
"count": len(incidents),
|
||||
})
|
||||
}
|
||||
|
||||
// GetIncidentsForAllDeliveries récupère incidents + routes pour tous livreurs actifs
|
||||
// GET /api/v2/admin/traffic/incidents/all
|
||||
func GetIncidentsForAllDeliveries(c *gin.Context) {
|
||||
database := c.MustGet("database").(*db.Database)
|
||||
|
||||
userRole := c.GetString("role")
|
||||
if userRole != "admin" {
|
||||
c.JSON(http.StatusForbidden, gin.H{"error": "Accès refusé"})
|
||||
return
|
||||
}
|
||||
|
||||
// Récupérer tous les livreurs disponibles depuis Redis
|
||||
livreurs, err := database.GetAvailableDeliveryPersonsRedis()
|
||||
if err != nil {
|
||||
c.JSON(http.StatusInternalServerError, gin.H{
|
||||
"error": "Erreur récupération livreurs",
|
||||
"details": err.Error(),
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
results := []gin.H{}
|
||||
|
||||
for _, livreur := range livreurs {
|
||||
username := livreur.Username
|
||||
status := livreur.Status
|
||||
|
||||
// Sauter les livreurs offline
|
||||
if status == "offline" {
|
||||
continue
|
||||
}
|
||||
|
||||
// Position livreur
|
||||
lat, lon, err := database.GetDeliveryPersonLocation(username)
|
||||
if err != nil {
|
||||
log.Printf("⚠️ Position non trouvée pour %s", username)
|
||||
continue
|
||||
}
|
||||
|
||||
// Vérifier s'il a une commande en cours
|
||||
commandID := livreur.CurrentCommand
|
||||
|
||||
if commandID == 0 {
|
||||
// Pas de livraison en cours
|
||||
results = append(results, gin.H{
|
||||
"username": username,
|
||||
"status": status,
|
||||
"location": gin.H{"latitude": lat, "longitude": lon},
|
||||
"has_delivery": false,
|
||||
"incidents": []gin.H{},
|
||||
"route": nil,
|
||||
})
|
||||
continue
|
||||
}
|
||||
|
||||
// Récupérer la commande
|
||||
command, err := database.GetCommandByID(commandID)
|
||||
if err != nil {
|
||||
log.Printf("⚠️ Commande %d non trouvée", commandID)
|
||||
continue
|
||||
}
|
||||
|
||||
// Coordonnées destination
|
||||
var destLat, destLon float64
|
||||
|
||||
if dLat, ok := getFloatFromMap(command, "dest_latitude"); ok && dLat != 0 {
|
||||
destLat = dLat
|
||||
}
|
||||
if dLon, ok := getFloatFromMap(command, "dest_longitude"); ok && dLon != 0 {
|
||||
destLon = dLon
|
||||
}
|
||||
|
||||
// Si pas de coordonnées, géocoder
|
||||
if destLat == 0 || destLon == 0 {
|
||||
address, ok := command["adresse"].(string)
|
||||
if !ok || address == "" || address == "Adresse non spécifiée" {
|
||||
continue
|
||||
}
|
||||
|
||||
geoService := c.MustGet("geoService").(*services.GeoService)
|
||||
location, err := geoService.GeocodeAddress(address)
|
||||
if err != nil {
|
||||
log.Printf("⚠️ Géocodage échoué pour %s", address)
|
||||
continue
|
||||
}
|
||||
|
||||
destLat = location.Latitude
|
||||
destLon = location.Longitude
|
||||
}
|
||||
|
||||
// Récupérer incidents sur le trajet
|
||||
incidents, _ := fetchIncidentsOnRoute(lat, lon, destLat, destLon)
|
||||
|
||||
// Convertir incidents en gin.H pour JSON
|
||||
incidentsJSON := make([]gin.H, len(incidents))
|
||||
for i, inc := range incidents {
|
||||
incidentsJSON[i] = gin.H{
|
||||
"type": inc.Type,
|
||||
"icon": inc.Icon,
|
||||
"description": inc.Description,
|
||||
}
|
||||
}
|
||||
|
||||
// Calculer route avec trafic
|
||||
routeSummary, err := fetchRouteSummary(lat, lon, destLat, destLon)
|
||||
if err != nil {
|
||||
log.Printf("⚠️ Erreur calcul route pour %s", username)
|
||||
routeSummary = models.RouteSummary{}
|
||||
}
|
||||
|
||||
results = append(results, gin.H{
|
||||
"username": username,
|
||||
"status": status,
|
||||
"location": gin.H{"latitude": lat, "longitude": lon},
|
||||
"destination": gin.H{"latitude": destLat, "longitude": destLon},
|
||||
"has_delivery": true,
|
||||
"command_id": commandID,
|
||||
"incidents": incidentsJSON,
|
||||
"route": routeSummary,
|
||||
})
|
||||
}
|
||||
|
||||
c.JSON(http.StatusOK, gin.H{
|
||||
"success": true,
|
||||
"deliveries": results,
|
||||
"count": len(results),
|
||||
})
|
||||
}
|
||||
|
||||
// ============================================
|
||||
// MISE À JOUR ETA AVEC TRAFIC
|
||||
// ============================================
|
||||
func UpdateETAWithRealTraffic(c *gin.Context) {
|
||||
database := c.MustGet("database").(*db.Database)
|
||||
|
||||
userRole := c.GetString("role")
|
||||
if userRole != "admin" && userRole != "livreur" {
|
||||
c.JSON(http.StatusForbidden, gin.H{"error": "Accès refusé"})
|
||||
return
|
||||
}
|
||||
|
||||
// Récupérer l'ID de la commande
|
||||
commandID, err := strconv.Atoi(c.Param("id"))
|
||||
if err != nil {
|
||||
c.JSON(http.StatusBadRequest, gin.H{"error": "ID invalide"})
|
||||
return
|
||||
}
|
||||
|
||||
// Récupérer la commande
|
||||
command, err := database.GetCommandByID(commandID)
|
||||
if err != nil {
|
||||
c.JSON(http.StatusNotFound, gin.H{
|
||||
"error": "Commande non trouvée",
|
||||
"command_id": commandID,
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
// Vérifier qu'un livreur est assigné
|
||||
livreurAssign, ok := command["livreur_assign"].(string)
|
||||
if !ok || livreurAssign == "" {
|
||||
c.JSON(http.StatusBadRequest, gin.H{
|
||||
"error": "Aucun livreur assigné",
|
||||
"command_id": commandID,
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
// Position actuelle du livreur
|
||||
lat, lon, err := database.GetDeliveryPersonLocation(livreurAssign)
|
||||
if err != nil {
|
||||
c.JSON(http.StatusNotFound, gin.H{
|
||||
"error": "Position livreur introuvable",
|
||||
"livreur": livreurAssign,
|
||||
"details": err.Error(),
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
var destLat, destLon float64
|
||||
|
||||
// 🔹 1. Tenter de récupérer depuis le cache Redis (clé spécifique pour destination)
|
||||
destCacheKey := fmt.Sprintf("command:destination:%d", commandID)
|
||||
destData, err := db.Redis.Get(db.RedisCtx, destCacheKey).Result()
|
||||
if err == nil && destData != "" {
|
||||
var coords struct {
|
||||
Lat float64 `json:"lat"`
|
||||
Lon float64 `json:"lon"`
|
||||
}
|
||||
if err := json.Unmarshal([]byte(destData), &coords); err == nil && coords.Lat != 0 && coords.Lon != 0 {
|
||||
destLat = coords.Lat
|
||||
destLon = coords.Lon
|
||||
log.Printf("📍 Destination trouvée dans cache Redis pour commande %d", commandID)
|
||||
}
|
||||
}
|
||||
|
||||
// 🔹 2. Fallback: récupérer depuis la DB
|
||||
if destLat == 0 || destLon == 0 {
|
||||
if dLat, okLat := getFloatFromMap(command, "dest_latitude"); okLat && dLat != 0 {
|
||||
destLat = dLat
|
||||
}
|
||||
if dLon, okLon := getFloatFromMap(command, "dest_longitude"); okLon && dLon != 0 {
|
||||
destLon = dLon
|
||||
}
|
||||
}
|
||||
|
||||
// 🔹 3. Si toujours pas de coordonnées, géocoder l'adresse
|
||||
if destLat == 0 || destLon == 0 {
|
||||
address, ok := command["adresse"].(string)
|
||||
if !ok || address == "" || address == "Adresse non spécifiée" {
|
||||
c.JSON(http.StatusBadRequest, gin.H{
|
||||
"error": "Adresse de destination manquante ou invalide",
|
||||
"command_id": commandID,
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
geoService := c.MustGet("geoService").(*services.GeoService)
|
||||
location, err := geoService.GeocodeAddress(address)
|
||||
if err != nil {
|
||||
c.JSON(http.StatusInternalServerError, gin.H{
|
||||
"error": "Impossible de géocoder l'adresse",
|
||||
"address": address,
|
||||
"command_id": commandID,
|
||||
"details": err.Error(),
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
destLat = location.Latitude
|
||||
destLon = location.Longitude
|
||||
log.Printf("📍 Adresse géocodée pour commande %d: %s -> (%.6f, %.6f)",
|
||||
commandID, address, destLat, destLon)
|
||||
}
|
||||
|
||||
// 🔹 4. Sauvegarder les coordonnées destination dans le cache Redis
|
||||
coordsJSON, _ := json.Marshal(map[string]float64{
|
||||
"lat": destLat,
|
||||
"lon": destLon,
|
||||
})
|
||||
if err := db.Redis.Set(db.RedisCtx, destCacheKey, coordsJSON, 4*time.Hour).Err(); err != nil {
|
||||
log.Printf("⚠️ Impossible de sauvegarder destination dans Redis: %v", err)
|
||||
}
|
||||
|
||||
// 🔹 5. Calculer le temps réel avec TomTom Routing API
|
||||
routeSummary, err := fetchRouteSummary(lat, lon, destLat, destLon)
|
||||
if err != nil {
|
||||
c.JSON(http.StatusInternalServerError, gin.H{
|
||||
"error": "Impossible de calculer l'itinéraire",
|
||||
"command_id": commandID,
|
||||
"from": gin.H{"lat": lat, "lon": lon},
|
||||
"to": gin.H{"lat": destLat, "lon": destLon},
|
||||
"details": err.Error(),
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
// 🔹 6. Mettre à jour l'ETA dans Redis
|
||||
err = database.SetCommandETA(commandID, routeSummary.TravelTimeInMinutes)
|
||||
if err != nil {
|
||||
c.JSON(http.StatusInternalServerError, gin.H{
|
||||
"error": "Erreur mise à jour ETA",
|
||||
"command_id": commandID,
|
||||
"details": err.Error(),
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
log.Printf("✅ ETA mis à jour pour commande %d: %d min (trafic réel inclus)",
|
||||
commandID, routeSummary.TravelTimeInMinutes)
|
||||
|
||||
c.JSON(http.StatusOK, gin.H{
|
||||
"success": true,
|
||||
"command_id": commandID,
|
||||
"eta_minutes": routeSummary.TravelTimeInMinutes,
|
||||
"distance_km": routeSummary.LengthInKm,
|
||||
"with_traffic": true,
|
||||
"route_summary": routeSummary,
|
||||
})
|
||||
}
|
||||
|
||||
// ============================================
|
||||
// FONCTIONS HELPERS - TOMTOM API
|
||||
// ============================================
|
||||
|
||||
// fetchIncidents récupère les incidents de trafic autour d'une position
|
||||
func fetchIncidents(lat, lon float64, radius int) ([]models.Incident, error) {
|
||||
apiKey := os.Getenv("TOMTOM_API_KEY")
|
||||
if apiKey == "" {
|
||||
return nil, fmt.Errorf("TOMTOM_API_KEY non configurée")
|
||||
}
|
||||
|
||||
// API TomTom Traffic Incidents
|
||||
url := fmt.Sprintf(
|
||||
"https://api.tomtom.com/traffic/services/5/incidentDetails?key=%s&bbox=%f,%f,%f,%f&fields={incidents{type,geometry{type,coordinates},properties{iconCategory,magnitudeOfDelay,events{description,code,iconCategory}}}}",
|
||||
apiKey,
|
||||
lon-0.05, lat-0.05, // Southwest corner
|
||||
lon+0.05, lat+0.05, // Northeast corner
|
||||
)
|
||||
|
||||
client := &http.Client{Timeout: 10 * time.Second}
|
||||
resp, err := client.Get(url)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("erreur requête incidents: %w", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
body, _ := io.ReadAll(resp.Body)
|
||||
return nil, fmt.Errorf("API incidents error %d: %s", resp.StatusCode, string(body))
|
||||
}
|
||||
|
||||
body, err := io.ReadAll(resp.Body)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("erreur lecture réponse: %w", err)
|
||||
}
|
||||
|
||||
var incidentResponse models.IncidentResponse
|
||||
err = json.Unmarshal(body, &incidentResponse)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("erreur parsing incidents: %w", err)
|
||||
}
|
||||
|
||||
// Convertir en []models.Incident
|
||||
incidents := make([]models.Incident, len(incidentResponse.Incidents))
|
||||
for i, inc := range incidentResponse.Incidents {
|
||||
incidents[i] = models.Incident{
|
||||
Type: inc.Type,
|
||||
Icon: inc.Icon,
|
||||
Description: inc.Description,
|
||||
}
|
||||
}
|
||||
|
||||
return incidents, nil
|
||||
}
|
||||
|
||||
// fetchIncidentsOnRoute récupère les incidents sur un trajet
|
||||
func fetchIncidentsOnRoute(startLat, startLon, destLat, destLon float64) ([]models.Incident, error) {
|
||||
// Calculer la bounding box du trajet
|
||||
minLat := min(startLat, destLat) - 0.02
|
||||
maxLat := max(startLat, destLat) + 0.02
|
||||
minLon := min(startLon, destLon) - 0.02
|
||||
maxLon := max(startLon, destLon) + 0.02
|
||||
|
||||
apiKey := os.Getenv("TOMTOM_API_KEY")
|
||||
if apiKey == "" {
|
||||
return []models.Incident{}, nil
|
||||
}
|
||||
|
||||
url := fmt.Sprintf(
|
||||
"https://api.tomtom.com/traffic/services/5/incidentDetails?key=%s&bbox=%f,%f,%f,%f&fields={incidents{type,geometry{type,coordinates},properties{iconCategory,magnitudeOfDelay,events{description,code,iconCategory}}}}",
|
||||
apiKey,
|
||||
minLon, minLat,
|
||||
maxLon, maxLat,
|
||||
)
|
||||
|
||||
client := &http.Client{Timeout: 10 * time.Second}
|
||||
resp, err := client.Get(url)
|
||||
if err != nil {
|
||||
return []models.Incident{}, nil
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
return []models.Incident{}, nil
|
||||
}
|
||||
|
||||
body, _ := io.ReadAll(resp.Body)
|
||||
|
||||
var incidentResponse models.IncidentResponse
|
||||
if err := json.Unmarshal(body, &incidentResponse); err != nil {
|
||||
return []models.Incident{}, nil
|
||||
}
|
||||
|
||||
// Convertir en []models.Incident
|
||||
incidents := make([]models.Incident, len(incidentResponse.Incidents))
|
||||
for i, inc := range incidentResponse.Incidents {
|
||||
incidents[i] = models.Incident{
|
||||
Type: inc.Type,
|
||||
Icon: inc.Icon,
|
||||
Description: inc.Description,
|
||||
}
|
||||
}
|
||||
|
||||
return incidents, nil
|
||||
}
|
||||
|
||||
// récupère le temps de trajet réel via l'API TomTom Routing
|
||||
// fetchRouteSummary récupère le temps de trajet réel via l'API TomTom Routing
|
||||
func fetchRouteSummary(startLat, startLon, destLat, destLon float64) (models.RouteSummary, error) {
|
||||
apiKey := os.Getenv("TOMTOM_API_KEY")
|
||||
if apiKey == "" {
|
||||
return models.RouteSummary{}, fmt.Errorf("TOMTOM_API_KEY non configurée")
|
||||
}
|
||||
|
||||
// Validation des coordonnées
|
||||
if startLat < -90 || startLat > 90 || destLat < -90 || destLat > 90 {
|
||||
return models.RouteSummary{}, fmt.Errorf("latitude invalide: start=%.6f, dest=%.6f", startLat, destLat)
|
||||
}
|
||||
if startLon < -180 || startLon > 180 || destLon < -180 || destLon > 180 {
|
||||
return models.RouteSummary{}, fmt.Errorf("longitude invalide: start=%.6f, dest=%.6f", startLon, destLon)
|
||||
}
|
||||
|
||||
// API TomTom Routing: Calculate Route
|
||||
url := fmt.Sprintf(
|
||||
"https://api.tomtom.com/routing/1/calculateRoute/%f,%f:%f,%f/json?key=%s&traffic=true&travelMode=car",
|
||||
startLat, startLon, destLat, destLon, apiKey,
|
||||
)
|
||||
|
||||
log.Printf("🛣️ Appel TomTom: (%.6f,%.6f) -> (%.6f,%.6f)", startLat, startLon, destLat, destLon)
|
||||
|
||||
// Timeout réduit à 8 secondes
|
||||
client := &http.Client{Timeout: 8 * time.Second}
|
||||
resp, err := client.Get(url)
|
||||
if err != nil {
|
||||
// Fallback: estimation basée sur distance Haversine
|
||||
distance := haversineDistance(startLat, startLon, destLat, destLon)
|
||||
estimatedMinutes := int(distance/25*60) + 3 // ~25 km/h en ville + 3 min marge
|
||||
if estimatedMinutes < 5 {
|
||||
estimatedMinutes = 5
|
||||
}
|
||||
|
||||
log.Printf("⚠️ TomTom timeout/erreur, fallback: %.2f km -> %d min estimé", distance, estimatedMinutes)
|
||||
|
||||
return models.RouteSummary{
|
||||
TravelTimeInMinutes: estimatedMinutes,
|
||||
LengthInKm: distance,
|
||||
}, nil // Pas d'erreur, on retourne l'estimation
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
io.ReadAll(resp.Body) // Lire et ignorer le body pour fermer proprement
|
||||
|
||||
// Fallback en cas d'erreur API
|
||||
distance := haversineDistance(startLat, startLon, destLat, destLon)
|
||||
estimatedMinutes := int(distance/25*60) + 3
|
||||
if estimatedMinutes < 5 {
|
||||
estimatedMinutes = 5
|
||||
}
|
||||
|
||||
log.Printf("⚠️ TomTom API error %d, fallback: %.2f km -> %d min", resp.StatusCode, distance, estimatedMinutes)
|
||||
|
||||
return models.RouteSummary{
|
||||
TravelTimeInMinutes: estimatedMinutes,
|
||||
LengthInKm: distance,
|
||||
}, nil
|
||||
}
|
||||
|
||||
body, err := io.ReadAll(resp.Body)
|
||||
if err != nil {
|
||||
return models.RouteSummary{}, fmt.Errorf("erreur lecture réponse: %w", err)
|
||||
}
|
||||
|
||||
var routeResponse models.RouteResponse
|
||||
err = json.Unmarshal(body, &routeResponse)
|
||||
if err != nil {
|
||||
return models.RouteSummary{}, fmt.Errorf("erreur parsing routing: %w", err)
|
||||
}
|
||||
|
||||
if len(routeResponse.Routes) == 0 {
|
||||
return models.RouteSummary{}, fmt.Errorf("aucun itinéraire trouvé")
|
||||
}
|
||||
|
||||
summary := routeResponse.Routes[0].Summary
|
||||
summary.TravelTimeInMinutes = (summary.TravelTimeInSeconds + 59) / 60
|
||||
summary.LengthInKm = float64(summary.LengthInMeters) / 1000.0
|
||||
|
||||
log.Printf("🛣️ Route calculée: %.2f km, %d min (trafic inclus)", summary.LengthInKm, summary.TravelTimeInMinutes)
|
||||
|
||||
return summary, nil
|
||||
}
|
||||
|
||||
// haversineDistance calcule la distance en km entre deux points GPS
|
||||
func haversineDistance(lat1, lon1, lat2, lon2 float64) float64 {
|
||||
const R = 6371.0 // Rayon Terre en km
|
||||
const toRad = math.Pi / 180.0
|
||||
|
||||
dLat := (lat2 - lat1) * toRad
|
||||
dLon := (lon2 - lon1) * toRad
|
||||
|
||||
a := math.Sin(dLat/2)*math.Sin(dLat/2) +
|
||||
math.Cos(lat1*toRad)*math.Cos(lat2*toRad)*
|
||||
math.Sin(dLon/2)*math.Sin(dLon/2)
|
||||
|
||||
c := 2 * math.Atan2(math.Sqrt(a), math.Sqrt(1-a))
|
||||
|
||||
return R * c
|
||||
}
|
||||
|
||||
// getFloatFromMap récupère un float64 depuis une map avec différents types
|
||||
func getFloatFromMap(m map[string]interface{}, key string) (float64, bool) {
|
||||
value, exists := m[key]
|
||||
if !exists || value == nil {
|
||||
return 0, false
|
||||
}
|
||||
|
||||
switch v := value.(type) {
|
||||
case float64:
|
||||
return v, true
|
||||
case float32:
|
||||
return float64(v), true
|
||||
case int:
|
||||
return float64(v), true
|
||||
case int64:
|
||||
return float64(v), true
|
||||
case int32:
|
||||
return float64(v), true
|
||||
case json.Number:
|
||||
f, err := v.Float64()
|
||||
if err != nil {
|
||||
return 0, false
|
||||
}
|
||||
return f, true
|
||||
case string:
|
||||
f, err := strconv.ParseFloat(v, 64)
|
||||
if err != nil {
|
||||
return 0, false
|
||||
}
|
||||
return f, true
|
||||
case []byte:
|
||||
s := string(v)
|
||||
f, err := strconv.ParseFloat(s, 64)
|
||||
if err != nil {
|
||||
return 0, false
|
||||
}
|
||||
return f, true
|
||||
default:
|
||||
return 0, false
|
||||
}
|
||||
}
|
||||
|
||||
// min retourne le minimum entre deux float64
|
||||
func min(a, b float64) float64 {
|
||||
if a < b {
|
||||
return a
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
// max retourne le maximum entre deux float64
|
||||
func max(a, b float64) float64 {
|
||||
if a > b {
|
||||
return a
|
||||
}
|
||||
return b
|
||||
}
|
||||
Reference in New Issue
Block a user