openteam/server/internal/api/admin_channel_models.go

package api

import (
	"encoding/json"
	"net/http"
	"strconv"
	"strings"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/openteam/server/internal/pkg/resp"
	"github.com/openteam/server/internal/store"
)

// AdminChannelRemoteModels GET /api/v1/admin/channels/:id/models/remote
// 拉取渠道接口的模型列表，返回本渠道尚未允许的模型（新增候选）。
// 每个渠道有各自的支持列表：只排除本渠道已允许的模型，其他渠道允许的同名模型仍可作为本渠道候选。
func (h *Handler) AdminChannelRemoteModels(c *gin.Context) {
	id, err := strconv.ParseUint(c.Param("id"), 10, 64)
	if err != nil {
		resp.Fail(c, http.StatusBadRequest, "invalid channel id")
		return
	}
	var ch store.Channel
	if err := h.a.DB.First(&ch, id).Error; err != nil {
		resp.Fail(c, http.StatusNotFound, "channel not found")
		return
	}
	key, err := h.a.Enc.Decrypt(ch.APIKeyEnc)
	if err != nil {
		resp.Fail(c, http.StatusInternalServerError, "failed to decrypt channel key")
		return
	}
	client := &http.Client{Timeout: 15 * time.Second}
	req, _ := http.NewRequest(http.MethodGet, ch.UpstreamURL("", "/models"), nil)
	req.Header.Set("Authorization", "Bearer "+key)
	req.Header.Set("Accept", "application/json")
	resp2, err := client.Do(req)
	if err != nil {
		resp.Fail(c, http.StatusBadGateway, "failed to reach channel: "+err.Error())
		return
	}
	defer resp2.Body.Close()
	if resp2.StatusCode != http.StatusOK {
		resp.Fail(c, http.StatusBadGateway, "channel returned http "+strconv.Itoa(resp2.StatusCode))
		return
	}
	var list struct {
		Data []struct {
			ID string `json:"id"`
		} `json:"data"`
	}
	if err := json.NewDecoder(resp2.Body).Decode(&list); err != nil {
		resp.Fail(c, http.StatusBadGateway, "failed to parse model list")
		return
	}
	// 本渠道已允许的上游模型名：不作为新增候选（其他渠道的模型仍可勾选）
	var boundNames []string
	h.a.DB.Model(&store.ChannelModelBinding{}).Where("channel_id = ?", id).Pluck("upstream_model", &boundNames)
	boundSet := make(map[string]bool, len(boundNames))
	for _, n := range boundNames {
		boundSet[strings.TrimSpace(n)] = true
	}

	items := make([]string, 0, len(list.Data))
	for _, m := range list.Data {
		name := strings.TrimSpace(m.ID)
		if name != "" && !boundSet[name] {
			items = append(items, name)
		}
	}
	resp.OK(c, gin.H{"items": items})
}

// AdminChannelModels GET /api/v1/admin/channels/:id/models — 渠道的模型绑定列表（含上游映射名）。
func (h *Handler) AdminChannelModels(c *gin.Context) {
	id, err := strconv.ParseUint(c.Param("id"), 10, 64)
	if err != nil {
		resp.Fail(c, http.StatusBadRequest, "invalid channel id")
		return
	}
	var bindings []store.ChannelModelBinding
	h.a.DB.Preload("Model").Where("channel_id = ?", id).Order("id ASC").Find(&bindings)
	out := make([]gin.H, 0, len(bindings))
	for _, b := range bindings {
		out = append(out, gin.H{
			"id":             b.ID,
			"model_id":       b.ModelID,
			"model_name":     b.Model.Name,
			"upstream_model": b.UpstreamModel,
			"weight":         b.Weight,
		})
	}
	resp.OK(c, gin.H{"items": out})
}

// AdminChannelAddModel POST /api/v1/admin/channels/:id/models — 手工添加渠道支持的模型。
// 无需渠道具备 /v1/models 接口：直接填上游模型名，可选自定义名称作为客户端调用名。
func (h *Handler) AdminChannelAddModel(c *gin.Context) {
	id, err := strconv.ParseUint(c.Param("id"), 10, 64)
	if err != nil {
		resp.Fail(c, http.StatusBadRequest, "invalid channel id")
		return
	}
	var req struct {
		UpstreamModel string `json:"upstream_model" binding:"required"` // 渠道侧真实模型名
		CustomName    string `json:"custom_name"`                      // 客户端调用名，空=用上游名
		Weight        *int   `json:"weight"`
	}
	if err := c.ShouldBindJSON(&req); err != nil {
		resp.Fail(c, http.StatusBadRequest, "invalid input")
		return
	}
	globalName := req.CustomName
	if globalName == "" {
		globalName = req.UpstreamModel
	}
	// 解析或创建全局模型（客户端名）
	var m store.Model
	if err := h.a.DB.Where("name = ?", globalName).First(&m).Error; err != nil {
		m = store.Model{Name: globalName, DisplayName: globalName, Enabled: true}
		if err := h.a.DB.Create(&m).Error; err != nil {
			resp.Fail(c, http.StatusInternalServerError, "failed to create model")
			return
		}
	}
	b := store.ChannelModelBinding{
		ChannelID: id, ModelID: m.ID, UpstreamModel: req.UpstreamModel, Weight: intOr(req.Weight, 1),
	}
	if err := h.a.DB.Create(&b).Error; err != nil {
		resp.Fail(c, http.StatusConflict, "binding may already exist")
		return
	}
	resp.Created(c, gin.H{"id": b.ID, "model_id": m.ID, "model_name": m.Name, "upstream_model": req.UpstreamModel, "weight": b.Weight})
}

// AdminChannelUpdateModel PATCH /api/v1/admin/channels/:id/models/:bid — 改映射名/权重。
func (h *Handler) AdminChannelUpdateModel(c *gin.Context) {
	bid, err := strconv.ParseUint(c.Param("bid"), 10, 64)
	if err != nil {
		resp.Fail(c, http.StatusBadRequest, "invalid binding id")
		return
	}
	var req struct {
		UpstreamModel *string `json:"upstream_model"`
		Weight        *int    `json:"weight"`
	}
	if err := c.ShouldBindJSON(&req); err != nil {
		resp.Fail(c, http.StatusBadRequest, "invalid input")
		return
	}
	updates := map[string]any{}
	if req.UpstreamModel != nil {
		updates["upstream_model"] = *req.UpstreamModel
	}
	if req.Weight != nil {
		updates["weight"] = *req.Weight
	}
	if len(updates) > 0 {
		res := h.a.DB.Model(&store.ChannelModelBinding{}).Where("id = ?", bid).Updates(updates)
		if res.Error != nil {
			resp.Fail(c, http.StatusInternalServerError, "failed to update binding")
			return
		}
		if res.RowsAffected == 0 {
			resp.Fail(c, http.StatusNotFound, "binding not found")
			return
		}
	}
	resp.OK(c, gin.H{"ok": true})
}

// AdminChannelDeleteModel DELETE /api/v1/admin/channels/:id/models/:bid — 解除绑定。
func (h *Handler) AdminChannelDeleteModel(c *gin.Context) {
	bid, err := strconv.ParseUint(c.Param("bid"), 10, 64)
	if err != nil {
		resp.Fail(c, http.StatusBadRequest, "invalid binding id")
		return
	}
	res := h.a.DB.Delete(&store.ChannelModelBinding{}, bid)
	if res.Error != nil {
		resp.Fail(c, http.StatusInternalServerError, "failed to delete binding")
		return
	}
	if res.RowsAffected == 0 {
		resp.Fail(c, http.StatusNotFound, "binding not found")
		return
	}
	resp.OK(c, gin.H{"ok": true})
}