274 lines
7.4 KiB
Go
274 lines
7.4 KiB
Go
package service
|
||
|
||
import (
|
||
"context"
|
||
"errors"
|
||
"sort"
|
||
|
||
"model-asynch/dao"
|
||
"model-asynch/model/dto"
|
||
"model-asynch/model/entity"
|
||
|
||
"gitea.com/red-future/common/utils"
|
||
"github.com/gogf/gf/v2/frame/g"
|
||
"github.com/gogf/gf/v2/util/gconv"
|
||
)
|
||
|
||
var Model = &modelService{}
|
||
|
||
type modelService struct{}
|
||
|
||
func (s *modelService) Create(ctx context.Context, req *dto.CreateModelReq) (res *dto.CreateModelRes, err error) {
|
||
m := &entity.AsynchModel{
|
||
ModelName: req.ModelName,
|
||
ModelsType: req.ModelsType,
|
||
BaseURL: req.BaseURL,
|
||
HttpMethod: req.HttpMethod,
|
||
HeadMsg: req.HeadMsg,
|
||
IsPrivate: req.IsPrivate,
|
||
Enabled: req.Enabled,
|
||
IsChatModel: req.IsChatModel,
|
||
ApiKey: req.ApiKey,
|
||
Form: req.Form,
|
||
RequestMapping: req.RequestMapping,
|
||
ResponseMapping: req.ResponseMapping,
|
||
ResponseBody: req.ResponseBody,
|
||
TokenMapping: req.TokenMapping,
|
||
MaxConcurrency: req.MaxConcurrency,
|
||
QueueLimit: req.QueueLimit,
|
||
TimeoutSeconds: req.TimeoutSeconds,
|
||
ExpectedSeconds: req.ExpectedSeconds,
|
||
RetryTimes: req.RetryTimes,
|
||
RetryQueueMaxSeconds: req.RetryQueueMaxSeconds,
|
||
AutoCleanSeconds: req.AutoCleanSeconds,
|
||
Remark: req.Remark,
|
||
}
|
||
id, err := dao.Model.Insert(ctx, m)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return &dto.CreateModelRes{ID: id}, nil
|
||
}
|
||
|
||
func (s *modelService) Update(ctx context.Context, req *dto.UpdateModelReq) error {
|
||
//根据当前 isChatModel 来判断是否更新模型
|
||
if req.IsChatModel == 1 {
|
||
user, err := utils.GetUserInfo(ctx)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
//判断当前用户是否有会话模型
|
||
model, err := dao.Model.GetByIsChatModel(ctx, user.UserName)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if model != nil {
|
||
return errors.New("用户已存在会话模型，不能创建新的会话模型")
|
||
}
|
||
_, err = dao.Model.Update(ctx, req)
|
||
return err
|
||
}
|
||
_, err := dao.Model.Update(ctx, req)
|
||
return err
|
||
}
|
||
|
||
func (s *modelService) Delete(ctx context.Context, id string) error {
|
||
_, err := dao.Model.DeleteByID(ctx, id)
|
||
return err
|
||
}
|
||
|
||
func (s *modelService) Get(ctx context.Context, id int64) (*entity.AsynchModel, error) {
|
||
model, err := dao.Model.Get(ctx, id)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
model.Form = ParseJSONField(model.Form)
|
||
model.RequestMapping = ParseJSONField(model.RequestMapping)
|
||
model.ResponseMapping = ParseJSONField(model.ResponseMapping)
|
||
model.ResponseBody = ParseJSONField(model.ResponseBody)
|
||
return model, nil
|
||
}
|
||
|
||
func (s *modelService) List(ctx context.Context, pageNum, pageSize int, req *dto.ListModelReq) (list []*entity.AsynchModel, total int64, err error) {
|
||
isSuperAdmin, err := IsSuperAdmin(ctx)
|
||
if err != nil {
|
||
return nil, 0, err
|
||
}
|
||
user, err := utils.GetUserInfo(ctx)
|
||
if err != nil {
|
||
return nil, 0, err
|
||
}
|
||
|
||
var models []*entity.AsynchModel
|
||
var count int64
|
||
|
||
if isSuperAdmin {
|
||
models, count, err = dao.Model.List(ctx, pageNum, pageSize, req.ModelName, req.ModelType, req.IsPrivate)
|
||
} else {
|
||
models, count, err = s.getModelsWithDedup(ctx, user.UserName, pageNum, pageSize, req.ModelName, req.ModelType, req.IsPrivate)
|
||
}
|
||
if err != nil {
|
||
return nil, 0, err
|
||
}
|
||
|
||
// 处理列表中每条记录的 JSONB 字段
|
||
for _, m := range models {
|
||
m.Form = ParseJSONField(m.Form)
|
||
m.RequestMapping = ParseJSONField(m.RequestMapping)
|
||
m.ResponseMapping = ParseJSONField(m.ResponseMapping)
|
||
m.ResponseBody = ParseJSONField(m.ResponseBody)
|
||
}
|
||
return models, count, nil
|
||
}
|
||
|
||
// getModelsWithDedup 获取普通用户的模型列表并去重
|
||
func (s *modelService) getModelsWithDedup(ctx context.Context, creator string, pageNum, pageSize int, modelNameLike string, modelType int, isPrivate int) (list []*entity.AsynchModel, total int64, err error) {
|
||
// 1. 查全量数据（不分页，便于去重）
|
||
allModels, err := dao.Model.GetByCreatorAndPlatform(ctx, creator, modelNameLike, modelType, isPrivate)
|
||
if err != nil {
|
||
return nil, 0, err
|
||
}
|
||
|
||
// 2. 按 modelName 去重，保留当前用户的
|
||
modelMap := make(map[string]*entity.AsynchModel)
|
||
for _, m := range allModels {
|
||
if m == nil {
|
||
continue
|
||
}
|
||
name := m.ModelName
|
||
|
||
_, ok := modelMap[name]
|
||
if !ok {
|
||
// 没有冲突，直接放进去
|
||
modelMap[name] = m
|
||
} else {
|
||
// 有冲突，保留当前用户创建的
|
||
if m.Creator == creator {
|
||
modelMap[name] = m
|
||
}
|
||
// 如果现有的就是当前用户的，不做任何替换
|
||
}
|
||
}
|
||
|
||
// 3. 转回切片并排序
|
||
deduped := make([]*entity.AsynchModel, 0, len(modelMap))
|
||
for _, m := range modelMap {
|
||
deduped = append(deduped, m)
|
||
}
|
||
sort.Slice(deduped, func(i, j int) bool {
|
||
return deduped[i].CreatedAt.After(deduped[j].CreatedAt)
|
||
})
|
||
|
||
// 4. 手动分页
|
||
total = int64(len(deduped))
|
||
if pageNum > 0 && pageSize > 0 {
|
||
start := (pageNum - 1) * pageSize
|
||
if start >= len(deduped) {
|
||
return []*entity.AsynchModel{}, total, nil
|
||
}
|
||
end := start + pageSize
|
||
if end > len(deduped) {
|
||
end = len(deduped)
|
||
}
|
||
deduped = deduped[start:end]
|
||
}
|
||
return deduped, total, nil
|
||
}
|
||
|
||
// GetModelTypesFromConfig 从配置文件读取模型类型
|
||
func GetModelTypesFromConfig(ctx context.Context) map[int]string {
|
||
typeMap := make(map[int]string)
|
||
|
||
// 读取配置
|
||
configMap := g.Cfg().MustGet(ctx, "modelType.types").Map()
|
||
for k, v := range configMap {
|
||
typeID := gconv.Int(k)
|
||
typeName := gconv.String(v)
|
||
if typeID > 0 && typeName != "" {
|
||
typeMap[typeID] = typeName
|
||
}
|
||
}
|
||
// 如果配置为空，使用默认值
|
||
if len(typeMap) == 0 {
|
||
typeMap = map[int]string{
|
||
1: "推理模型",
|
||
2: "图片模型",
|
||
3: "音频模型",
|
||
4: "向量化模型",
|
||
5: "全模态模型",
|
||
}
|
||
}
|
||
return typeMap
|
||
}
|
||
|
||
func (s *modelService) UpdateChatModel(ctx context.Context, req *dto.UpdateChatModelReq) error {
|
||
user, err := utils.GetUserInfo(ctx)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
// 校验新会话模型是否存在
|
||
newModel, err := dao.Model.Get(ctx, req.Id)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if newModel == nil {
|
||
return errors.New("新会话模型不存在")
|
||
}
|
||
|
||
// 获取当前用户会话模型
|
||
currentModel, err := dao.Model.GetByIsChatModel(ctx, user.UserName)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if currentModel.ModelsType != 1 {
|
||
return errors.New("当前模型为非推理模型,不能设置为会话模型")
|
||
}
|
||
|
||
// 如果点击的就是当前会话模型（已经是1），取消它（设为0）
|
||
if currentModel != nil && currentModel.Id == req.Id {
|
||
_, err = dao.Model.UpdateByID(ctx, &dto.UpdateModelReq{
|
||
ID: req.Id,
|
||
IsChatModel: 0,
|
||
})
|
||
return err
|
||
}
|
||
|
||
// 如果之前有会话模型，取消它（设为0）
|
||
if currentModel != nil {
|
||
_, err = dao.Model.UpdateByID(ctx, &dto.UpdateModelReq{
|
||
ID: currentModel.Id,
|
||
IsChatModel: 0,
|
||
})
|
||
if err != nil {
|
||
return err
|
||
}
|
||
}
|
||
|
||
// 设置当前为会话模型（设为1）
|
||
_, err = dao.Model.UpdateByID(ctx, &dto.UpdateModelReq{
|
||
ID: req.Id,
|
||
IsChatModel: 1,
|
||
})
|
||
return err
|
||
}
|
||
|
||
func (s *modelService) GetIsChatModel(ctx context.Context) (*entity.AsynchModel, error) {
|
||
user, err := utils.GetUserInfo(ctx)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
model, err := dao.Model.GetByIsChatModel(ctx, user.UserName)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if model == nil {
|
||
return nil, nil
|
||
}
|
||
model.Form = ParseJSONField(model.Form)
|
||
model.RequestMapping = ParseJSONField(model.RequestMapping)
|
||
model.ResponseMapping = ParseJSONField(model.ResponseMapping)
|
||
model.ResponseBody = ParseJSONField(model.ResponseBody)
|
||
return model, nil
|
||
}
|