new-api/service/asset_resolver.go

package service

import (
	"errors"
	"fmt"
	"net/http"
	"strings"

	"github.com/QuantumNous/new-api/common"
	"github.com/QuantumNous/new-api/constant"
	"github.com/QuantumNous/new-api/model"
	"gorm.io/gorm"
)

// assetCredentialConfigured guards channel types whose asset adapter signs
// requests with a dedicated AK/SK pair stored in channel_asset_credentials
// (currently only official Volcengine DoubaoVideo). Without the credential
// the channel must not serve, be bound, or be auto-matched for assets; a DB
// error is treated as not configured so auto-match falls through to other
// candidate channels.
func assetCredentialConfigured(channel *model.Channel) bool {
	if channel.Type != constant.ChannelTypeDoubaoVideo {
		return true
	}
	credential, err := model.GetChannelAssetCredential(channel.Id)
	if err != nil || credential == nil {
		return false
	}
	return strings.TrimSpace(credential.AccessKey) != "" && strings.TrimSpace(credential.SecretKey) != ""
}

func ResolveAssetChannelForOperation(userID int, tokenGroup string, operation AssetOperation) (*model.Channel, AssetAdapter, *AssetError) {
	bindings, err := model.GetUserAssetChannelsByTypes(userID, RegisteredAssetChannelTypes(), tokenGroup)
	if err != nil {
		return nil, nil, newAssetError(AssetErrorServer, err.Error(), http.StatusInternalServerError)
	}
	if len(bindings) > 0 {
		binding := bindings[0]
		channel, err := model.CacheGetChannel(binding.ChannelId)
		if err != nil {
			if errors.Is(err, gorm.ErrRecordNotFound) || common.MemoryCacheEnabled {
				return nil, nil, newAssetError(AssetErrorBindingInvalid, "bound asset channel not found", http.StatusBadGateway)
			}
			return nil, nil, newAssetError(AssetErrorServer, err.Error(), http.StatusInternalServerError)
		}
		adapter, ok := GetAssetAdapter(channel.Type)
		if channel.Status != common.ChannelStatusEnabled || !assetChannelHasKey(channel) || !MatchDoubaoAssetGroup(channel.GetGroups(), tokenGroup) || !ok || !assetCredentialConfigured(channel) {
			return nil, nil, newAssetError(AssetErrorBindingInvalid, "bound asset channel is not available for asset library", http.StatusBadGateway)
		}
		if !adapter.Supports(operation) {
			return nil, nil, newAssetError(AssetErrorOperationNotSupported, fmt.Sprintf("asset operation %s is not supported by bound channel", operation), http.StatusBadRequest)
		}
		return channel, adapter, nil
	}

	channel, adapter, err := autoMatchAssetChannelForOperation(tokenGroup, operation)
	if err != nil {
		return nil, nil, newAssetError(AssetErrorServer, err.Error(), http.StatusInternalServerError)
	}
	if channel == nil {
		return nil, nil, newAssetError(AssetErrorChannelNotFound, "no available asset channel supports requested operation", http.StatusBadGateway)
	}
	// Persist the auto-matched channel as the user's asset binding so later
	// asset and video requests stay on the same channel (asset:// references
	// are passed through verbatim and must match the upload channel). This
	// mirrors the video-task binding backfill. Binding is best-effort: a
	// failure must not fail the asset operation itself.
	if family, ok := VideoAssetFamilyForChannelType(channel.Type); ok && tokenGroup != "" && tokenGroup != "auto" {
		if bindErr := BindVideoAssetChannel(userID, tokenGroup, channel, family); bindErr != nil {
			common.SysLog(fmt.Sprintf("failed to persist asset channel binding for user %d group %s channel %d: %s", userID, tokenGroup, channel.Id, bindErr.Error()))
		}
	}
	return channel, adapter, nil
}

func autoMatchAssetChannelForOperation(tokenGroup string, operation AssetOperation) (*model.Channel, AssetAdapter, error) {
	for _, channelType := range RegisteredAssetChannelTypes() {
		adapter, ok := GetAssetAdapter(channelType)
		if !ok || !adapter.Supports(operation) {
			continue
		}
		for startIdx := 0; ; startIdx += DoubaoAssetChannelPageSize {
			candidates, err := model.GetChannelsByType(startIdx, DoubaoAssetChannelPageSize, true, channelType)
			if err != nil {
				return nil, nil, err
			}
			for _, candidate := range candidates {
				if candidate == nil || !MatchDoubaoAssetGroup(candidate.GetGroups(), tokenGroup) {
					continue
				}
				channel, err := model.CacheGetChannel(candidate.Id)
				if err != nil {
					if errors.Is(err, gorm.ErrRecordNotFound) || common.MemoryCacheEnabled {
						continue
					}
					return nil, nil, err
				}
				if channel.Status == common.ChannelStatusEnabled && assetChannelHasKey(channel) && MatchDoubaoAssetGroup(channel.GetGroups(), tokenGroup) && assetCredentialConfigured(channel) {
					return channel, adapter, nil
				}
			}
			if len(candidates) < DoubaoAssetChannelPageSize {
				break
			}
		}
	}
	return nil, nil, nil
}