Merge pull request #2027 from xyfacai/refactor/openai-video

refactor: Openai video model 移动到 dto

relay/common/relay_video.go → dto/openai_video.go

-package common
+package dto
 
 
 import (
 import (
 	"strconv"
 	"strconv"

model/task.go

@@ -6,6 +6,7 @@ import (
 	"time"
 	"time"
 
 
 	"github.com/QuantumNous/new-api/constant"
 	"github.com/QuantumNous/new-api/constant"
+	"github.com/QuantumNous/new-api/dto"
 	commonRelay "github.com/QuantumNous/new-api/relay/common"
 	commonRelay "github.com/QuantumNous/new-api/relay/common"
 )
 )
 
 
@@ -15,15 +16,15 @@ func (t TaskStatus) ToVideoStatus() string {
 	var status string
 	var status string
 	switch t {
 	switch t {
 	case TaskStatusQueued, TaskStatusSubmitted:
 	case TaskStatusQueued, TaskStatusSubmitted:
-		status = commonRelay.VideoStatusQueued
+		status = dto.VideoStatusQueued
 	case TaskStatusInProgress:
 	case TaskStatusInProgress:
-		status = commonRelay.VideoStatusInProgress
+		status = dto.VideoStatusInProgress
 	case TaskStatusSuccess:
 	case TaskStatusSuccess:
-		status = commonRelay.VideoStatusCompleted
+		status = dto.VideoStatusCompleted
 	case TaskStatusFailure:
 	case TaskStatusFailure:
-		status = commonRelay.VideoStatusFailed
+		status = dto.VideoStatusFailed
 	default:
 	default:
-		status = commonRelay.VideoStatusUnknown // Default fallback
+		status = dto.VideoStatusUnknown // Default fallback
 	}
 	}
 	return status
 	return status
 }
 }

relay/channel/adapter.go

@@ -53,5 +53,5 @@ type TaskAdaptor interface {
 }
 }
 
 
 type OpenAIVideoConverter interface {
 type OpenAIVideoConverter interface {
-	ConvertToOpenAIVideo(originTask *model.Task) (*relaycommon.OpenAIVideo, error)
+	ConvertToOpenAIVideo(originTask *model.Task) (*dto.OpenAIVideo, error)
 }
 }

relay/channel/task/jimeng/adaptor.go

@@ -158,7 +158,7 @@ func (a *TaskAdaptor) DoResponse(c *gin.Context, resp *http.Response, info *rela
 		return
 		return
 	}
 	}
 
 
-	ov := relaycommon.NewOpenAIVideo()
+	ov := dto.NewOpenAIVideo()
 	ov.ID = jResp.Data.TaskID
 	ov.ID = jResp.Data.TaskID
 	ov.TaskID = jResp.Data.TaskID
 	ov.TaskID = jResp.Data.TaskID
 	ov.CreatedAt = time.Now().Unix()
 	ov.CreatedAt = time.Now().Unix()
@@ -405,13 +405,13 @@ func (a *TaskAdaptor) ParseTaskResult(respBody []byte) (*relaycommon.TaskInfo, e
 	return &taskResult, nil
 	return &taskResult, nil
 }
 }
 
 
-func (a *TaskAdaptor) ConvertToOpenAIVideo(originTask *model.Task) (*relaycommon.OpenAIVideo, error) {
+func (a *TaskAdaptor) ConvertToOpenAIVideo(originTask *model.Task) (*dto.OpenAIVideo, error) {
 	var jimengResp responseTask
 	var jimengResp responseTask
 	if err := json.Unmarshal(originTask.Data, &jimengResp); err != nil {
 	if err := json.Unmarshal(originTask.Data, &jimengResp); err != nil {
 		return nil, errors.Wrap(err, "unmarshal jimeng task data failed")
 		return nil, errors.Wrap(err, "unmarshal jimeng task data failed")
 	}
 	}
 
 
-	openAIVideo := relaycommon.NewOpenAIVideo()
+	openAIVideo := dto.NewOpenAIVideo()
 	openAIVideo.ID = originTask.TaskID
 	openAIVideo.ID = originTask.TaskID
 	openAIVideo.Status = originTask.Status.ToVideoStatus()
 	openAIVideo.Status = originTask.Status.ToVideoStatus()
 	openAIVideo.SetProgressStr(originTask.Progress)
 	openAIVideo.SetProgressStr(originTask.Progress)
@@ -420,7 +420,7 @@ func (a *TaskAdaptor) ConvertToOpenAIVideo(originTask *model.Task) (*relaycommon
 	openAIVideo.CompletedAt = originTask.UpdatedAt
 	openAIVideo.CompletedAt = originTask.UpdatedAt
 
 
 	if jimengResp.Code != 10000 {
 	if jimengResp.Code != 10000 {
-		openAIVideo.Error = &relaycommon.OpenAIVideoError{
+		openAIVideo.Error = &dto.OpenAIVideoError{
 			Message: jimengResp.Message,
 			Message: jimengResp.Message,
 			Code:    fmt.Sprintf("%d", jimengResp.Code),
 			Code:    fmt.Sprintf("%d", jimengResp.Code),
 		}
 		}

relay/channel/task/kling/adaptor.go

@@ -188,7 +188,7 @@ func (a *TaskAdaptor) DoResponse(c *gin.Context, resp *http.Response, info *rela
 		taskErr = service.TaskErrorWrapperLocal(fmt.Errorf(kResp.Message), "task_failed", http.StatusBadRequest)
 		taskErr = service.TaskErrorWrapperLocal(fmt.Errorf(kResp.Message), "task_failed", http.StatusBadRequest)
 		return
 		return
 	}
 	}
-	ov := relaycommon.NewOpenAIVideo()
+	ov := dto.NewOpenAIVideo()
 	ov.ID = kResp.Data.TaskId
 	ov.ID = kResp.Data.TaskId
 	ov.TaskID = kResp.Data.TaskId
 	ov.TaskID = kResp.Data.TaskId
 	ov.CreatedAt = time.Now().Unix()
 	ov.CreatedAt = time.Now().Unix()
@@ -367,13 +367,13 @@ func isNewAPIRelay(apiKey string) bool {
 	return strings.HasPrefix(apiKey, "sk-")
 	return strings.HasPrefix(apiKey, "sk-")
 }
 }
 
 
-func (a *TaskAdaptor) ConvertToOpenAIVideo(originTask *model.Task) (*relaycommon.OpenAIVideo, error) {
+func (a *TaskAdaptor) ConvertToOpenAIVideo(originTask *model.Task) (*dto.OpenAIVideo, error) {
 	var klingResp responsePayload
 	var klingResp responsePayload
 	if err := json.Unmarshal(originTask.Data, &klingResp); err != nil {
 	if err := json.Unmarshal(originTask.Data, &klingResp); err != nil {
 		return nil, errors.Wrap(err, "unmarshal kling task data failed")
 		return nil, errors.Wrap(err, "unmarshal kling task data failed")
 	}
 	}
 
 
-	openAIVideo := relaycommon.NewOpenAIVideo()
+	openAIVideo := dto.NewOpenAIVideo()
 	openAIVideo.ID = originTask.TaskID
 	openAIVideo.ID = originTask.TaskID
 	openAIVideo.Status = originTask.Status.ToVideoStatus()
 	openAIVideo.Status = originTask.Status.ToVideoStatus()
 	openAIVideo.SetProgressStr(originTask.Progress)
 	openAIVideo.SetProgressStr(originTask.Progress)
@@ -391,7 +391,7 @@ func (a *TaskAdaptor) ConvertToOpenAIVideo(originTask *model.Task) (*relaycommon
 	}
 	}
 
 
 	if klingResp.Code != 0 && klingResp.Message != "" {
 	if klingResp.Code != 0 && klingResp.Message != "" {
-		openAIVideo.Error = &relaycommon.OpenAIVideoError{
+		openAIVideo.Error = &dto.OpenAIVideoError{
 			Message: klingResp.Message,
 			Message: klingResp.Message,
 			Code:    fmt.Sprintf("%d", klingResp.Code),
 			Code:    fmt.Sprintf("%d", klingResp.Code),
 		}
 		}

relay/channel/task/sora/adaptor.go

@@ -186,8 +186,8 @@ func (a *TaskAdaptor) ParseTaskResult(respBody []byte) (*relaycommon.TaskInfo, e
 	return &taskResult, nil
 	return &taskResult, nil
 }
 }
 
 
-func (a *TaskAdaptor) ConvertToOpenAIVideo(task *model.Task) (*relaycommon.OpenAIVideo, error) {
-	openAIVideo := &relaycommon.OpenAIVideo{}
+func (a *TaskAdaptor) ConvertToOpenAIVideo(task *model.Task) (*dto.OpenAIVideo, error) {
+	openAIVideo := &dto.OpenAIVideo{}
 	err := json.Unmarshal(task.Data, openAIVideo)
 	err := json.Unmarshal(task.Data, openAIVideo)
 	if err != nil {
 	if err != nil {
 		return nil, errors.Wrap(err, "unmarshal to OpenAIVideo failed")
 		return nil, errors.Wrap(err, "unmarshal to OpenAIVideo failed")

relay/channel/task/vidu/adaptor.go

@@ -155,7 +155,7 @@ func (a *TaskAdaptor) DoResponse(c *gin.Context, resp *http.Response, info *rela
 		return
 		return
 	}
 	}
 
 
-	ov := relaycommon.NewOpenAIVideo()
+	ov := dto.NewOpenAIVideo()
 	ov.ID = vResp.TaskId
 	ov.ID = vResp.TaskId
 	ov.TaskID = vResp.TaskId
 	ov.TaskID = vResp.TaskId
 	ov.CreatedAt = time.Now().Unix()
 	ov.CreatedAt = time.Now().Unix()
@@ -263,13 +263,13 @@ func (a *TaskAdaptor) ParseTaskResult(respBody []byte) (*relaycommon.TaskInfo, e
 	return taskInfo, nil
 	return taskInfo, nil
 }
 }
 
 
-func (a *TaskAdaptor) ConvertToOpenAIVideo(originTask *model.Task) (*relaycommon.OpenAIVideo, error) {
+func (a *TaskAdaptor) ConvertToOpenAIVideo(originTask *model.Task) (*dto.OpenAIVideo, error) {
 	var viduResp taskResultResponse
 	var viduResp taskResultResponse
 	if err := json.Unmarshal(originTask.Data, &viduResp); err != nil {
 	if err := json.Unmarshal(originTask.Data, &viduResp); err != nil {
 		return nil, errors.Wrap(err, "unmarshal vidu task data failed")
 		return nil, errors.Wrap(err, "unmarshal vidu task data failed")
 	}
 	}
 
 
-	openAIVideo := relaycommon.NewOpenAIVideo()
+	openAIVideo := dto.NewOpenAIVideo()
 	openAIVideo.ID = originTask.TaskID
 	openAIVideo.ID = originTask.TaskID
 	openAIVideo.Status = originTask.Status.ToVideoStatus()
 	openAIVideo.Status = originTask.Status.ToVideoStatus()
 	openAIVideo.SetProgressStr(originTask.Progress)
 	openAIVideo.SetProgressStr(originTask.Progress)
@@ -281,7 +281,7 @@ func (a *TaskAdaptor) ConvertToOpenAIVideo(originTask *model.Task) (*relaycommon
 	}
 	}
 
 
 	if viduResp.State == "failed" && viduResp.ErrCode != "" {
 	if viduResp.State == "failed" && viduResp.ErrCode != "" {
-		openAIVideo.Error = &relaycommon.OpenAIVideoError{
+		openAIVideo.Error = &dto.OpenAIVideoError{
 			Message: viduResp.ErrCode,
 			Message: viduResp.ErrCode,
 			Code:    viduResp.ErrCode,
 			Code:    viduResp.ErrCode,
 		}
 		}