lassistanoque/backend/internal/http/handlers/provider.go

package handlers

import (
	"net/http"

	"github.com/labstack/echo/v5"
	"trankilou.fr/lassistanoque/backend/internal/domain"
	"trankilou.fr/lassistanoque/backend/internal/service/auth"
	"trankilou.fr/lassistanoque/backend/internal/service/provider"
)

func NewModelGroup(prefix string, e *echo.Group, service *provider.Service, middlewares ...echo.MiddlewareFunc) *echo.Group {
	modelHandler := &ModelHandler{
		providerService: service,
	}
	model := e.Group(prefix, middlewares...)

	model.GET("/providerTypes", modelHandler.ListProviderTypes)
	model.GET("/:space", modelHandler.ListProviders)
	model.GET("/:space/models", modelHandler.ListProvidersModels)
	model.POST("/:space/avalable-models", modelHandler.ListAvailableModels)
	model.GET("/:space/:provider", modelHandler.GetProvider)
	model.PUT("/:space", modelHandler.UpdateProvider)
	model.POST("/:space", modelHandler.CreateProvider)
	model.DELETE("/:space/:provider", modelHandler.DeleteProvider)

	return model
}

type ModelHandler struct {
	providerService *provider.Service
}

func (h *ModelHandler) ListProviderTypes(c *echo.Context) error {
	return c.JSON(http.StatusOK, h.providerService.ListProviderTypes())
}

func (h *ModelHandler) ListProviders(c *echo.Context) error {
	userID := c.Get(auth.ContextUserIDKey).(string)
	teamID := c.Param("space")
	providers, err := h.providerService.ListProviders(userID, teamID)
	if err != nil {
		c.Logger().Error("error listing providers", "error", err)
		return echo.NewHTTPError(http.StatusBadRequest, "error listing providers")
	}
	return c.JSON(http.StatusOK, providers)
}

func (h *ModelHandler) GetProvider(c *echo.Context) error {
	userID := c.Get(auth.ContextUserIDKey).(string)
	teamID := c.Param("space")
	providerID := c.Param("provider")
	provider, err := h.providerService.GetProvider(userID, teamID, providerID)
	if err != nil {
		c.Logger().Error("error getting provider", "error", err)
		return echo.NewHTTPError(http.StatusBadRequest, "error getting provider")
	}
	return c.JSON(http.StatusOK, provider)
}

func (h *ModelHandler) CreateProvider(c *echo.Context) error {
	userID := c.Get(auth.ContextUserIDKey).(string)
	teamID := c.Param("space")
	var provider domain.Provider
	err := c.Bind(&provider)
	if err != nil {
		c.Logger().Error("error binding provider", "error", err)
		return echo.NewHTTPError(http.StatusBadRequest, "error binding provider")
	}
	provider.TeamID = teamID
	updprovider, err := h.providerService.CreateProvider(userID, &provider)
	if err != nil {
		c.Logger().Error("error creating provider", "error", err)
		return echo.NewHTTPError(http.StatusBadRequest, "error creating provider")
	}
	return c.JSON(http.StatusOK, updprovider)
}

func (h *ModelHandler) UpdateProvider(c *echo.Context) error {
	userID := c.Get(auth.ContextUserIDKey).(string)
	teamID := c.Param("space")
	var provider domain.Provider
	err := c.Bind(&provider)
	if err != nil {
		c.Logger().Error("error binding provider", "error", err)
		return echo.NewHTTPError(http.StatusBadRequest, "error binding provider")
	}
	provider.TeamID = teamID
	updprovider, err := h.providerService.UpdateProvider(userID, &provider)
	if err != nil {
		c.Logger().Error("error updating provider", "error", err)
		return echo.NewHTTPError(http.StatusBadRequest, "error creating provider")
	}
	return c.JSON(http.StatusOK, updprovider)
}

func (h *ModelHandler) DeleteProvider(c *echo.Context) error {
	userID := c.Get(auth.ContextUserIDKey).(string)
	teamID := c.Param("space")
	providerID := c.Param("provider")
	err := h.providerService.DeleteProvider(userID, teamID, providerID)
	if err != nil {
		c.Logger().Error("error creating provider", "error", err)
		return echo.NewHTTPError(http.StatusBadRequest, "error creating provider")
	}
	return c.JSON(http.StatusOK, providerID)
}

func (h *ModelHandler) ListAvailableModels(c *echo.Context) error {
	teamID := c.Param("space")
	var provider domain.Provider
	err := c.Bind(&provider)
	if err != nil {
		c.Logger().Error("error binding provider", "error", err)
		return echo.NewHTTPError(http.StatusBadRequest, "error binding provider")
	}
	provider.TeamID = teamID
	list, err := h.providerService.ListAvailableModels(c.Request().Context(), &provider)
	if err != nil {
		c.Logger().Error("error listing available models", "error", err)
		return echo.NewHTTPError(http.StatusBadRequest, "error listing available models")
	}
	return c.JSON(http.StatusOK, list)
}

func (h *ModelHandler) ListProvidersModels(c *echo.Context) error {
	userID := c.Get(auth.ContextUserIDKey).(string)
	teamID := c.Param("space")
	list, err := h.providerService.ListProvidersModels(userID, teamID)
	if err != nil {
		c.Logger().Error("error listing providers models", "error", err)
		return echo.NewHTTPError(http.StatusBadRequest, "error listing providers models")
	}
	return c.JSON(http.StatusOK, list)
}