409 lines
13 KiB
Go
409 lines
13 KiB
Go
package auth
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"infinite-canvas/backend/internal/kernel"
|
|
"math"
|
|
"net/url"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
func adaptTapNowDetail(detail *tapNowDetail, shareID string) (*TapNowImportResult, error) {
|
|
if detail == nil {
|
|
return nil, errors.New("TapNow 画布数据为空")
|
|
}
|
|
shareID = strings.TrimSpace(shareID)
|
|
if !isTapNowShareID(shareID) {
|
|
return nil, kernel.BadAuthRequest("TapNow 分享 ID 格式无效")
|
|
}
|
|
if len(detail.Nodes) > tapNowMaxNodes {
|
|
return nil, fmt.Errorf("TapNow 画布节点过多（最多支持 %d 个）", tapNowMaxNodes)
|
|
}
|
|
|
|
now := time.Now()
|
|
batchID := "tapnow-" + strconv.FormatInt(now.UnixMilli(), 36) + "-" + strings.ReplaceAll(uuid.NewString(), "-", "")[:8]
|
|
result := &TapNowImportResult{
|
|
BatchID: batchID,
|
|
BatchCreatedAt: now,
|
|
ShareID: shareID,
|
|
ProjectName: strings.TrimSpace(detail.Name),
|
|
Nodes: make([]TapNowCanvasNode, 0, len(detail.Nodes)),
|
|
Connections: make([]TapNowCanvasConnection, 0, minInt(len(detail.Connections), tapNowMaxConnections)),
|
|
SkippedNodes: make([]TapNowImportIssue, 0),
|
|
SkippedConnections: make([]TapNowImportIssue, 0),
|
|
Warnings: make([]TapNowImportWarning, 0),
|
|
}
|
|
if result.ProjectName == "" {
|
|
result.ProjectName = "TapNow 画布"
|
|
}
|
|
|
|
mapping := make(map[string]string, len(detail.Nodes))
|
|
seenNodeIDs := make(map[string]struct{}, len(detail.Nodes))
|
|
for _, raw := range detail.Nodes {
|
|
if strings.TrimSpace(raw.DeletedAt) != "" {
|
|
continue
|
|
}
|
|
nodeID := strings.TrimSpace(raw.ID)
|
|
if nodeID == "" && raw.ShortID != 0 {
|
|
nodeID = strconv.FormatInt(raw.ShortID, 10)
|
|
}
|
|
if nodeID == "" {
|
|
result.SkippedNodes = append(result.SkippedNodes, TapNowImportIssue{Reason: "节点缺少 ID"})
|
|
continue
|
|
}
|
|
if len(nodeID) > 128 {
|
|
result.SkippedNodes = append(result.SkippedNodes, TapNowImportIssue{ID: nodeID[:128], Reason: "节点 ID 过长"})
|
|
continue
|
|
}
|
|
if _, exists := seenNodeIDs[nodeID]; exists {
|
|
result.SkippedNodes = append(result.SkippedNodes, TapNowImportIssue{ID: nodeID, Reason: "节点 ID 重复"})
|
|
continue
|
|
}
|
|
seenNodeIDs[nodeID] = struct{}{}
|
|
|
|
data, err := decodeTapNowNodeData(raw.Data)
|
|
if err != nil {
|
|
result.SkippedNodes = append(result.SkippedNodes, TapNowImportIssue{ID: nodeID, Reason: "节点数据格式无效"})
|
|
continue
|
|
}
|
|
kind := strings.ToLower(strings.TrimSpace(raw.Type))
|
|
if kind == "" {
|
|
kind = strings.ToLower(strings.TrimSpace(data.Type))
|
|
}
|
|
if kind != "image" && kind != "video" && kind != "audio" && kind != "text" {
|
|
result.SkippedNodes = append(result.SkippedNodes, TapNowImportIssue{ID: nodeID, Name: strings.TrimSpace(data.Title), Reason: "暂不支持的节点类型"})
|
|
continue
|
|
}
|
|
if !finiteNumber(raw.Position.X) || !finiteNumber(raw.Position.Y) {
|
|
result.SkippedNodes = append(result.SkippedNodes, TapNowImportIssue{ID: nodeID, Name: strings.TrimSpace(data.Title), Reason: "节点坐标无效"})
|
|
continue
|
|
}
|
|
|
|
content, mediaIndex := firstTapNowMediaURL(data)
|
|
if kind == "text" {
|
|
content = strings.TrimSpace(data.Text)
|
|
if content == "" {
|
|
content = strings.TrimSpace(data.Prompt)
|
|
}
|
|
mediaIndex = -1
|
|
}
|
|
width, height := raw.Measured.Width, raw.Measured.Height
|
|
if !positiveFiniteNumber(width) {
|
|
width = 480
|
|
}
|
|
if !positiveFiniteNumber(height) {
|
|
height = 300
|
|
}
|
|
item := TapNowCanvasNode{
|
|
ID: "tapnow-" + batchID + "-" + nodeID,
|
|
Type: kind,
|
|
Title: strings.TrimSpace(data.Title),
|
|
X: raw.Position.X,
|
|
Y: raw.Position.Y,
|
|
Width: width,
|
|
Height: height,
|
|
Content: content,
|
|
Prompt: kernel.FirstNonEmpty(strings.TrimSpace(data.Prompt), firstTapNowParam(data.Params, "prompt")),
|
|
Model: tapNowMapString(data.Params, "model"),
|
|
Size: firstTapNowParam(data.Params, "aspectRatio", "size"),
|
|
Quality: tapNowImageQuality(data.Params),
|
|
Seconds: firstTapNowParam(data.Params, "duration", "seconds"),
|
|
VQuality: firstTapNowParam(data.Params, "resolution", "vquality"),
|
|
GenerateAudio: tapNowBoolParam(data.Params, "generateAudio"),
|
|
Metadata: TapNowImportMetadata{
|
|
Provider: "tapnow",
|
|
ShareID: shareID,
|
|
NodeID: nodeID,
|
|
BatchID: batchID,
|
|
SourceType: strings.TrimSpace(data.Type),
|
|
},
|
|
}
|
|
if item.Title == "" {
|
|
item.Title = kind + " 节点"
|
|
}
|
|
item.NaturalWidth = data.Metadata.Width
|
|
item.NaturalHeight = data.Metadata.Height
|
|
if data.Metadata.Duration > 0 && !math.IsNaN(data.Metadata.Duration) && !math.IsInf(data.Metadata.Duration, 0) {
|
|
item.DurationMs = int64(math.Round(data.Metadata.Duration * 1000))
|
|
}
|
|
item.MimeType = inferTapNowMime(kind, content, kernel.FirstNonEmpty(data.Prompt, data.Title))
|
|
taskStatus := tapNowTaskStatus(data.TaskInfo)
|
|
hasContent := strings.TrimSpace(content) != ""
|
|
if hasContent {
|
|
item.Status = "success"
|
|
if tapNowTaskFailed(taskStatus) {
|
|
result.ReusedFailedNodeCount++
|
|
}
|
|
} else if tapNowTaskFailed(taskStatus) {
|
|
item.Status = "error"
|
|
item.ErrorDetails = tapNowErrorDetails(data)
|
|
if item.ErrorDetails == "" {
|
|
item.ErrorDetails = "TapNow 生成任务失败"
|
|
}
|
|
result.PlaceholderNodeCount++
|
|
} else {
|
|
item.Status = "idle"
|
|
result.PlaceholderNodeCount++
|
|
}
|
|
mapping[nodeID] = item.ID
|
|
if raw.ShortID != 0 {
|
|
mapping[strconv.FormatInt(raw.ShortID, 10)] = item.ID
|
|
}
|
|
result.Nodes = append(result.Nodes, item)
|
|
if !positiveFiniteNumber(raw.Measured.Width) || !positiveFiniteNumber(raw.Measured.Height) {
|
|
result.Warnings = append(result.Warnings, TapNowImportWarning{ID: nodeID, Message: fmt.Sprintf("节点“%s”尺寸无效，已使用默认尺寸。", item.Title)})
|
|
}
|
|
if mediaIndex >= 0 && len(data.Options) > 1 {
|
|
result.MultiResultNodeCount++
|
|
result.Warnings = append(result.Warnings, TapNowImportWarning{ID: nodeID, Message: fmt.Sprintf("节点“%s”包含多个结果，已导入首个结果。", item.Title)})
|
|
}
|
|
}
|
|
|
|
if len(detail.Connections) > tapNowMaxConnections {
|
|
result.Warnings = append(result.Warnings, TapNowImportWarning{Message: fmt.Sprintf("连接超过 %d 条，仅处理前 %d 条。", tapNowMaxConnections, tapNowMaxConnections)})
|
|
}
|
|
seenConnectionIDs := make(map[string]struct{}, len(detail.Connections))
|
|
for index, raw := range detail.Connections {
|
|
if index >= tapNowMaxConnections {
|
|
break
|
|
}
|
|
if strings.TrimSpace(raw.DeletedAt) != "" {
|
|
continue
|
|
}
|
|
connectionID := strings.TrimSpace(raw.ID)
|
|
if connectionID == "" {
|
|
result.SkippedConnections = append(result.SkippedConnections, TapNowImportIssue{Reason: "连接缺少 ID"})
|
|
continue
|
|
}
|
|
if _, exists := seenConnectionIDs[connectionID]; exists {
|
|
result.SkippedConnections = append(result.SkippedConnections, TapNowImportIssue{ID: connectionID, Reason: "连接 ID 重复"})
|
|
continue
|
|
}
|
|
seenConnectionIDs[connectionID] = struct{}{}
|
|
from, okFrom := mapping[strings.TrimSpace(raw.Source)]
|
|
to, okTo := mapping[strings.TrimSpace(raw.Target)]
|
|
if !okFrom || !okTo {
|
|
result.SkippedConnections = append(result.SkippedConnections, TapNowImportIssue{ID: connectionID, Reason: "连接端点节点未导入"})
|
|
continue
|
|
}
|
|
fromHandleID := strings.TrimSpace(raw.SourceHandle)
|
|
toHandleID := strings.TrimSpace(raw.TargetHandle)
|
|
if toHandleID == "" {
|
|
// TapNow 将图片输入句柄放在边 data.valueKey，而不是 targetHandle。
|
|
toHandleID = tapNowMapString(raw.Data, "valueKey")
|
|
}
|
|
result.Connections = append(result.Connections, TapNowCanvasConnection{
|
|
ID: "tapnow-" + batchID + "-" + connectionID,
|
|
FromNodeID: from,
|
|
ToNodeID: to,
|
|
FromHandleID: fromHandleID,
|
|
ToHandleID: toHandleID,
|
|
})
|
|
}
|
|
result.ImportedNodeCount = len(result.Nodes)
|
|
result.ImportedConnectionCount = len(result.Connections)
|
|
if result.ImportedNodeCount == 0 {
|
|
return nil, errors.New("TapNow 画布没有可导入的有效节点")
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func decodeTapNowNodeData(raw json.RawMessage) (tapNowNodeData, error) {
|
|
var data tapNowNodeData
|
|
trimmed := strings.TrimSpace(string(raw))
|
|
if strings.HasPrefix(trimmed, `"`) {
|
|
var encoded string
|
|
if err := json.Unmarshal(raw, &encoded); err != nil {
|
|
return data, err
|
|
}
|
|
raw = json.RawMessage(encoded)
|
|
}
|
|
if err := json.Unmarshal(raw, &data); err != nil {
|
|
return data, err
|
|
}
|
|
return data, nil
|
|
}
|
|
|
|
func firstTapNowMediaURL(data tapNowNodeData) (string, int) {
|
|
values := make([]string, 0, len(data.Options)+2)
|
|
values = append(values, data.Src)
|
|
values = append(values, data.Options...)
|
|
values = append(values, data.Metadata.URL)
|
|
for index, value := range values {
|
|
parsed, err := url.Parse(strings.TrimSpace(value))
|
|
if err != nil || parsed.Scheme != "https" || parsed.Hostname() == "" || parsed.User != nil || !isTapNowMediaHost(parsed.Hostname()) {
|
|
continue
|
|
}
|
|
return parsed.String(), index
|
|
}
|
|
return "", -1
|
|
}
|
|
|
|
func isTapNowMediaHost(host string) bool {
|
|
host = strings.TrimSuffix(strings.ToLower(strings.TrimSpace(host)), ".")
|
|
// 导入后的媒体还可能作为后续生成的参考素材，只接受已核验的官方文件域名，
|
|
// 不能根据品牌前缀放行未经确认的同名域，避免把外部 URL 带入后端出网链路。
|
|
return host == "files.tapnow.media"
|
|
}
|
|
|
|
func inferTapNowMime(kind, rawURL, hint string) string {
|
|
lower := strings.ToLower(rawURL + " " + hint)
|
|
switch kind {
|
|
case "image":
|
|
switch {
|
|
case strings.Contains(lower, ".png"):
|
|
return "image/png"
|
|
case strings.Contains(lower, ".jpg") || strings.Contains(lower, ".jpeg"):
|
|
return "image/jpeg"
|
|
case strings.Contains(lower, ".webp"):
|
|
return "image/webp"
|
|
case strings.Contains(lower, ".gif"):
|
|
return "image/gif"
|
|
default:
|
|
return "image/*"
|
|
}
|
|
case "video":
|
|
switch {
|
|
case strings.Contains(lower, ".webm"):
|
|
return "video/webm"
|
|
case strings.Contains(lower, ".mov"):
|
|
return "video/quicktime"
|
|
default:
|
|
return "video/mp4"
|
|
}
|
|
case "audio":
|
|
switch {
|
|
case strings.Contains(lower, ".wav"):
|
|
return "audio/wav"
|
|
case strings.Contains(lower, ".flac"):
|
|
return "audio/flac"
|
|
case strings.Contains(lower, ".ogg") || strings.Contains(lower, ".oga"):
|
|
return "audio/ogg"
|
|
case strings.Contains(lower, ".m4a"):
|
|
return "audio/mp4"
|
|
default:
|
|
return "audio/mpeg"
|
|
}
|
|
case "text":
|
|
return "text/plain"
|
|
default:
|
|
return "application/octet-stream"
|
|
}
|
|
}
|
|
|
|
func tapNowMapString(values map[string]any, key string) string {
|
|
if values == nil {
|
|
return ""
|
|
}
|
|
value, ok := values[key]
|
|
if !ok {
|
|
return ""
|
|
}
|
|
if value == nil {
|
|
return ""
|
|
}
|
|
if stringValue, ok := value.(string); ok {
|
|
return strings.TrimSpace(stringValue)
|
|
}
|
|
return strings.TrimSpace(fmt.Sprint(value))
|
|
}
|
|
|
|
func firstTapNowParam(values map[string]any, keys ...string) string {
|
|
for _, key := range keys {
|
|
if value := tapNowMapString(values, key); value != "" {
|
|
return value
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// TapNow 部分渠道用 imageSize（例如 "2K"），画布合同则使用小写质量档位。
|
|
// 只迁移已知档位，避免把渠道私有值静默写成无效的本地质量设置。
|
|
func tapNowImageQuality(values map[string]any) string {
|
|
value := firstTapNowParam(values, "quality")
|
|
if value == "" {
|
|
value = firstTapNowParam(values, "imageSize")
|
|
}
|
|
normalized := strings.ToLower(strings.TrimSpace(value))
|
|
switch normalized {
|
|
case "1k", "2k", "4k", "auto", "low", "medium", "high":
|
|
return normalized
|
|
default:
|
|
return ""
|
|
}
|
|
}
|
|
|
|
func tapNowBoolParam(values map[string]any, key string) string {
|
|
value, ok := values[key]
|
|
if !ok {
|
|
return ""
|
|
}
|
|
if boolean, ok := value.(bool); ok {
|
|
return strconv.FormatBool(boolean)
|
|
}
|
|
return tapNowMapString(values, key)
|
|
}
|
|
|
|
func tapNowTaskStatus(values map[string]any) string {
|
|
status := strings.ToLower(strings.TrimSpace(tapNowMapString(values, "status")))
|
|
return status
|
|
}
|
|
|
|
func tapNowTaskFailed(status string) bool {
|
|
switch strings.ToLower(strings.TrimSpace(status)) {
|
|
case "failed", "error", "failure":
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func tapNowErrorDetails(data tapNowNodeData) string {
|
|
if value := strings.TrimSpace(data.Error); value != "" {
|
|
return value
|
|
}
|
|
if value := strings.TrimSpace(data.FailedReason); value != "" {
|
|
return value
|
|
}
|
|
for _, key := range []string{"error", "failedReason", "message"} {
|
|
if value := tapNowMapString(data.TaskInfo, key); value != "" {
|
|
return value
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func isTapNowShareID(value string) bool {
|
|
value = strings.TrimSpace(value)
|
|
if value == "" || len(value) > 64 {
|
|
return false
|
|
}
|
|
for _, char := range value {
|
|
if !((char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z') || (char >= '0' && char <= '9') || char == '_' || char == '-') {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func finiteNumber(value float64) bool {
|
|
return !math.IsNaN(value) && !math.IsInf(value, 0)
|
|
}
|
|
|
|
func positiveFiniteNumber(value float64) bool {
|
|
return finiteNumber(value) && value > 0
|
|
}
|
|
|
|
func minInt(left, right int) int {
|
|
if left < right {
|
|
return left
|
|
}
|
|
return right
|
|
}
|