109 lines
3.4 KiB
Go
109 lines
3.4 KiB
Go
package handlers
|
|
|
|
import (
|
|
"net/http"
|
|
|
|
"github.com/google/uuid"
|
|
"veza-backend-api/internal/services"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
)
|
|
|
|
// BitrateHandler gère les requêtes pour l'adaptation de bitrate
|
|
// T0349: Create Bitrate Adaptation Endpoint
|
|
type BitrateHandler struct {
|
|
adaptationService *services.BitrateAdaptationService
|
|
}
|
|
|
|
// NewBitrateHandler crée un nouveau handler de bitrate
|
|
func NewBitrateHandler(adaptationService *services.BitrateAdaptationService) *BitrateHandler {
|
|
return &BitrateHandler{
|
|
adaptationService: adaptationService,
|
|
}
|
|
}
|
|
|
|
// AdaptBitrateRequest représente la requête pour adapter le bitrate
|
|
type AdaptBitrateRequest struct {
|
|
CurrentBitrate int `json:"current_bitrate" binding:"required"`
|
|
Bandwidth int64 `json:"bandwidth" binding:"required"`
|
|
BufferLevel float64 `json:"buffer_level" binding:"required"`
|
|
}
|
|
|
|
// AdaptBitrate gère la requête POST /api/v1/tracks/:id/bitrate/adapt
|
|
// Reçoit les métriques de streaming et retourne le bitrate recommandé
|
|
func (h *BitrateHandler) AdaptBitrate(c *gin.Context) {
|
|
// Récupérer l'ID de l'utilisateur depuis le contexte (défini par le middleware d'authentification)
|
|
userID := c.MustGet("user_id").(uuid.UUID)
|
|
if userID == uuid.Nil {
|
|
c.JSON(http.StatusUnauthorized, gin.H{"error": "unauthorized"})
|
|
return
|
|
}
|
|
|
|
// Récupérer l'ID du track depuis les paramètres de l'URL
|
|
trackIDStr := c.Param("id")
|
|
trackID, err := uuid.Parse(trackIDStr)
|
|
if err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid track id"})
|
|
return
|
|
}
|
|
|
|
// Valider et parser le body de la requête
|
|
var req AdaptBitrateRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
// Appeler le service d'adaptation de bitrate
|
|
newBitrate, err := h.adaptationService.AdaptBitrate(
|
|
c.Request.Context(),
|
|
trackID,
|
|
userID,
|
|
req.CurrentBitrate,
|
|
req.Bandwidth,
|
|
req.BufferLevel,
|
|
)
|
|
if err != nil {
|
|
// Le service retourne des erreurs de validation avec des messages spécifiques
|
|
// On peut distinguer les erreurs de validation des erreurs internes
|
|
if err.Error() == "invalid track ID: 0" ||
|
|
err.Error() == "invalid user ID: nil UUID" ||
|
|
err.Error() == "invalid current bitrate: 0" ||
|
|
err.Error()[:14] == "invalid buffer" {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
// Retourner le bitrate recommandé
|
|
c.JSON(http.StatusOK, gin.H{"recommended_bitrate": newBitrate})
|
|
}
|
|
|
|
// GetAnalytics gère la requête GET /api/v1/tracks/:id/bitrate/analytics
|
|
// Retourne les statistiques d'adaptation de bitrate pour un track
|
|
// T0354: Create Bitrate Adaptation Analytics Endpoint
|
|
func (h *BitrateHandler) GetAnalytics(c *gin.Context) {
|
|
// Récupérer l'ID du track depuis les paramètres de l'URL
|
|
trackIDStr := c.Param("id")
|
|
trackID, err := uuid.Parse(trackIDStr)
|
|
if err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid track id"})
|
|
return
|
|
}
|
|
|
|
// Récupérer les analytics depuis le service
|
|
analytics, err := h.adaptationService.GetAnalytics(c.Request.Context(), trackID)
|
|
if err != nil {
|
|
if err.Error() == "invalid track ID: 0" {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid track id"})
|
|
return
|
|
}
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
// Retourner les analytics
|
|
c.JSON(http.StatusOK, gin.H{"analytics": analytics})
|
|
}
|