perf(platform): 短剧创作工作台 - 拆分长篇项目接口并优化章节与素材分页

This commit is contained in:
ddCat committed 2026-08-30 01:32:33 +08:00
1 parent 40fd0c54a4
commit d89f170a08
22 files changed
+1497 -222

No files matched your search

@@ -0,0 +1,356 @@
package service
import (
"infinite-canvas/backend/internal/model"
"golang.org/x/sync/errgroup"
)
type ProjectCore struct {
Project model.Project `json:"project"`
}
type ProjectUnitSummaries struct {
Units []model.ProjectUnit `json:"units"`
CanvasCounts map[string]int64 `json:"canvasCounts"`
}
type ProjectOverview struct {
Metrics ProjectOverviewMetrics `json:"metrics"`
Units []ProjectOverviewUnit `json:"units"`
}
type ProjectOverviewMetrics struct {
UnitCount int64 `json:"unitCount"`
CompletedUnitCount int64 `json:"completedUnitCount"`
TotalWordCount int64 `json:"totalWordCount"`
UnitsWithoutText int64 `json:"unitsWithoutText"`
UnitsWithoutShots int64 `json:"unitsWithoutShots"`
CanvasCount int64 `json:"canvasCount"`
AssetCount int64 `json:"assetCount"`
ShotCount int64 `json:"shotCount"`
PendingCandidateCount int64 `json:"pendingCandidateCount"`
ReadyStoryboardCount int64 `json:"readyStoryboardCount"`
ReadyPrevizCount int64 `json:"readyPrevizCount"`
ReadyVideoCount int64 `json:"readyVideoCount"`
StaleArtifactCount int64 `json:"staleArtifactCount"`
}
type ProjectOverviewUnit struct {
Unit model.ProjectUnit `json:"unit"`
ShotCount int64 `json:"shotCount"`
CandidateCount int64 `json:"candidateCount"`
CanvasCount int64 `json:"canvasCount"`
}
type ProjectUnitWorkspace struct {
Unit model.ProjectUnit `json:"unit"`
Workflows []ProjectWorkflowDetail `json:"workflows"`
Shots []model.Shot `json:"shots"`
ShotRevisions []model.ShotRevision `json:"shotRevisions"`
ShotArtifacts []model.ShotArtifact `json:"shotArtifacts"`
ShotReferences []model.ShotAssetReference `json:"shotReferences"`
AssetCandidates []model.ProjectAssetCandidate `json:"assetCandidates"`
Assets []ProjectAssetSummary `json:"assets"`
Tasks []TaskSummary `json:"tasks"`
}
type ProjectCanvasPage struct {
Canvases []model.CanvasProject `json:"canvases"`
CanvasUnitLinks []model.CanvasUnitLink `json:"canvasUnitLinks"`
Page int `json:"page"`
PageSize int `json:"pageSize"`
Total int64 `json:"total"`
HasMore bool `json:"hasMore"`
}
type ProjectAssetCandidatePage struct {
Candidates []model.ProjectAssetCandidate `json:"candidates"`
Page int `json:"page"`
PageSize int `json:"pageSize"`
Total int64 `json:"total"`
HasMore bool `json:"hasMore"`
}
type ProjectAssetPage struct {
Assets []ProjectAssetSummary `json:"assets"`
CategoryCounts map[string]int64 `json:"categoryCounts"`
FolderCounts map[string]int64 `json:"folderCounts"`
Page int `json:"page"`
PageSize int `json:"pageSize"`
Total int64 `json:"total"`
HasMore bool `json:"hasMore"`
}
func (s *Service) ProjectCore(userID string, projectID string) (ProjectCore, error) {
project, err := s.repo.ProjectForUser(userID, projectID)
if err != nil {
return ProjectCore{}, err
}
if s.reconcileCharacterTurnaroundTasks(userID, project.ID) {
project, err = s.repo.ProjectForUser(userID, projectID)
if err != nil {
return ProjectCore{}, err
}
}
return ProjectCore{Project: *project}, nil
}
func (s *Service) ProjectUnitSummaries(userID string, projectID string) (ProjectUnitSummaries, error) {
if _, err := s.repo.ProjectForUser(userID, projectID); err != nil {
return ProjectUnitSummaries{}, err
}
var units []model.ProjectUnit
var canvasCounts map[string]int64
var group errgroup.Group
group.Go(func() error {
var err error
units, err = s.repo.ProjectUnitSummaries(projectID)
return err
})
group.Go(func() error {
var err error
canvasCounts, err = s.repo.ProjectUnitCanvasCounts(projectID)
return err
})
if err := group.Wait(); err != nil {
return ProjectUnitSummaries{}, err
}
return ProjectUnitSummaries{Units: units, CanvasCounts: canvasCounts}, nil
}
func (s *Service) ProjectOverview(userID string, projectID string) (ProjectOverview, error) {
if _, err := s.repo.ProjectForUser(userID, projectID); err != nil {
return ProjectOverview{}, err
}
var metrics ProjectOverviewMetrics
var units []ProjectOverviewUnit
var group errgroup.Group
group.Go(func() error {
row, err := s.repo.ProjectOverviewMetrics(projectID)
if err != nil {
return err
}
metrics = ProjectOverviewMetrics{
UnitCount: row.UnitCount, CompletedUnitCount: row.CompletedUnitCount, TotalWordCount: row.TotalWordCount,
UnitsWithoutText: row.UnitsWithoutText, UnitsWithoutShots: row.UnitsWithoutShots, CanvasCount: row.CanvasCount,
AssetCount: row.AssetCount, ShotCount: row.ShotCount, PendingCandidateCount: row.PendingCandidateCount,
ReadyStoryboardCount: row.ReadyStoryboardCount, ReadyPrevizCount: row.ReadyPrevizCount, ReadyVideoCount: row.ReadyVideoCount,
StaleArtifactCount: row.StaleArtifactCount,
}
return nil
})
group.Go(func() error {
rows, err := s.repo.ProjectOverviewUnits(projectID, 8)
if err != nil {
return err
}
units = make([]ProjectOverviewUnit, 0, len(rows))
for _, row := range rows {
units = append(units, ProjectOverviewUnit{Unit: row.ProjectUnit, ShotCount: row.ShotCount, CandidateCount: row.CandidateCount, CanvasCount: row.CanvasCount})
}
return nil
})
if err := group.Wait(); err != nil {
return ProjectOverview{}, err
}
return ProjectOverview{Metrics: metrics, Units: units}, nil
}
func (s *Service) ProjectUnitWorkspace(userID string, projectID string, unitID string) (ProjectUnitWorkspace, error) {
if _, err := s.repo.ProjectForUser(userID, projectID); err != nil {
return ProjectUnitWorkspace{}, err
}
unit, err := s.repo.ProjectUnit(projectID, unitID)
if err != nil {
return ProjectUnitWorkspace{}, err
}
result := ProjectUnitWorkspace{Unit: *unit}
var projectTasks []TaskSummary
var group errgroup.Group
group.Go(func() error {
var err error
result.Shots, err = s.repo.ProjectUnitShots(projectID, unitID)
return err
})
group.Go(func() error {
var err error
result.ShotRevisions, err = s.repo.ProjectUnitShotRevisions(projectID, unitID)
return err
})
group.Go(func() error {
var err error
result.ShotArtifacts, err = s.repo.ProjectUnitShotArtifacts(projectID, unitID)
return err
})
group.Go(func() error {
var err error
result.ShotReferences, err = s.repo.ProjectUnitShotAssetReferences(projectID, unitID)
return err
})
group.Go(func() error {
var err error
result.AssetCandidates, err = s.repo.ProjectUnitAssetCandidates(projectID, unitID)
return err
})
group.Go(func() error {
assets, err := s.repo.ProjectUnitAssets(userID, projectID, unitID)
if err != nil {
return err
}
result.Assets = make([]ProjectAssetSummary, len(assets))
var summaries errgroup.Group
summaries.SetLimit(8)
for index := range assets {
index := index
summaries.Go(func() error {
summary, summaryErr := s.projectAssetSummary(userID, projectID, &assets[index])
if summaryErr == nil {
result.Assets[index] = summary
}
return summaryErr
})
}
return summaries.Wait()
})
group.Go(func() error {
instances, err := s.repo.ProjectWorkflowInstancesForUnit(projectID, unitID)
if err != nil {
return err
}
result.Workflows = make([]ProjectWorkflowDetail, 0, len(instances))
for _, instance := range instances {
steps, stepsErr := s.repo.WorkflowSteps(instance.ID)
if stepsErr != nil {
return stepsErr
}
result.Workflows = append(result.Workflows, ProjectWorkflowDetail{Instance: instance, Steps: steps})
}
return nil
})
group.Go(func() error {
recent, err := s.TasksWithOptions(userID, TaskListOptions{Limit: 100, ProjectID: projectID})
if err != nil {
return err
}
active, err := s.TasksWithOptions(userID, TaskListOptions{Limit: 100, ProjectID: projectID, ActiveOnly: true})
if err != nil {
return err
}
seen := make(map[string]struct{}, len(recent)+len(active))
projectTasks = make([]TaskSummary, 0, len(recent)+len(active))
for _, task := range append(active, recent...) {
if _, exists := seen[task.ID]; exists {
continue
}
seen[task.ID] = struct{}{}
projectTasks = append(projectTasks, task)
}
return nil
})
if err := group.Wait(); err != nil {
return ProjectUnitWorkspace{}, err
}
shotIDs := make(map[string]struct{}, len(result.Shots))
for _, shot := range result.Shots {
shotIDs[shot.ID] = struct{}{}
}
result.Tasks = make([]TaskSummary, 0, len(projectTasks))
for _, task := range projectTasks {
context := task.ClientContext
if context == nil {
continue
}
_, belongsToShot := shotIDs[context.ShotID]
if context.ChapterID == unitID || belongsToShot {
result.Tasks = append(result.Tasks, task)
}
}
return result, nil
}
func (s *Service) ProjectCanvasesPage(userID string, projectID string, page int, pageSize int) (ProjectCanvasPage, error) {
if _, err := s.repo.ProjectForUser(userID, projectID); err != nil {
return ProjectCanvasPage{}, err
}
page, pageSize = normalizeProjectPage(page, pageSize, 100)
canvases, total, err := s.repo.ProjectCanvasSummariesPage(userID, projectID, page, pageSize)
if err != nil {
return ProjectCanvasPage{}, err
}
ids := make([]string, 0, len(canvases))
for _, canvas := range canvases {
ids = append(ids, canvas.ID)
}
links, err := s.repo.ProjectCanvasUnitLinksForCanvases(projectID, ids)
if err != nil {
return ProjectCanvasPage{}, err
}
return ProjectCanvasPage{Canvases: canvases, CanvasUnitLinks: links, Page: page, PageSize: pageSize, Total: total, HasMore: int64(page*pageSize) < total}, nil
}
func (s *Service) ProjectAssetCandidatesPage(userID string, projectID string, page int, pageSize int, unitID string, status string, category string) (ProjectAssetCandidatePage, error) {
if _, err := s.repo.ProjectForUser(userID, projectID); err != nil {
return ProjectAssetCandidatePage{}, err
}
page, pageSize = normalizeProjectPage(page, pageSize, 200)
candidates, total, err := s.repo.ProjectAssetCandidatesPage(projectID, page, pageSize, unitID, status, category)
if err != nil {
return ProjectAssetCandidatePage{}, err
}
return ProjectAssetCandidatePage{Candidates: candidates, Page: page, PageSize: pageSize, Total: total, HasMore: int64(page*pageSize) < total}, nil
}
func (s *Service) ProjectAssetsPage(userID string, projectID string, page int, pageSize int, category string, mediaType string, status string, folderID *string, query string) (ProjectAssetPage, error) {
if _, err := s.repo.ProjectForUser(userID, projectID); err != nil {
return ProjectAssetPage{}, err
}
page, pageSize = normalizeProjectPage(page, pageSize, 80)
assets, total, err := s.repo.ProjectAssetsPage(userID, projectID, page, pageSize, category, mediaType, status, folderID, query)
if err != nil {
return ProjectAssetPage{}, err
}
summaries := make([]ProjectAssetSummary, len(assets))
var group errgroup.Group
group.SetLimit(8)
for index := range assets {
index := index
group.Go(func() error {
summary, summaryErr := s.projectAssetSummary(userID, projectID, &assets[index])
if summaryErr != nil {
return summaryErr
}
summaries[index] = summary
return nil
})
}
if err := group.Wait(); err != nil {
return ProjectAssetPage{}, err
}
categoryRows, folderRows, err := s.repo.ProjectAssetFacets(projectID)
if err != nil {
return ProjectAssetPage{}, err
}
categoryCounts := make(map[string]int64, len(categoryRows))
for _, row := range categoryRows {
categoryCounts[row.Key] = row.Count
}
folderCounts := make(map[string]int64, len(folderRows))
for _, row := range folderRows {
folderCounts[row.Key] = row.Count
}
return ProjectAssetPage{Assets: summaries, CategoryCounts: categoryCounts, FolderCounts: folderCounts, Page: page, PageSize: pageSize, Total: total, HasMore: int64(page*pageSize) < total}, nil
}
func normalizeProjectPage(page int, pageSize int, maximum int) (int, int) {
if page < 1 {
page = 1
}
if pageSize < 1 {
pageSize = 40
}
if pageSize > maximum {
pageSize = maximum
}
return page, pageSize
}
@@ -0,0 +1,187 @@
package service
import (
"fmt"
"testing"
"time"
"infinite-canvas/backend/internal/model"
"infinite-canvas/backend/internal/repository"
"gorm.io/driver/sqlite"
"gorm.io/gorm"
)
func newProjectWorkbenchReadTestService(t *testing.T) (*Service, *gorm.DB) {
t.Helper()
db, err := gorm.Open(sqlite.Open("file:"+newID()+"?mode=memory&cache=shared"), &gorm.Config{})
if err != nil {
t.Fatal(err)
}
if err := db.AutoMigrate(
&model.Project{}, &model.ProjectUnit{}, &model.CanvasProject{}, &model.CanvasUnitLink{},
&model.Asset{}, &model.AssetVersion{}, &model.AssetRepresentation{}, &model.ProjectAssetLink{}, &model.ProjectAssetCandidate{},
&model.Shot{}, &model.ShotRevision{}, &model.ShotArtifact{}, &model.ShotAssetReference{},
&model.WorkflowInstance{}, &model.WorkflowStepInstance{}, &model.Task{},
); err != nil {
t.Fatal(err)
}
return &Service{repo: repository.New(db)}, db
}
func seedWorkbenchProject(t *testing.T, db *gorm.DB) model.Project {
t.Helper()
project := model.Project{ID: "project-1", UserID: "user-1", Name: "长篇短剧", Status: model.ProjectStatusActive}
if err := db.Create(&project).Error; err != nil {
t.Fatal(err)
}
return project
}
func TestProjectOverviewUsesAggregatesWithoutLoadingProjectCollections(t *testing.T) {
service, db := newProjectWorkbenchReadTestService(t)
project := seedWorkbenchProject(t, db)
for index := 0; index < 12; index++ {
status := model.ProjectUnitStatusReady
if index < 3 {
status = model.ProjectUnitStatusCompleted
}
unit := model.ProjectUnit{ID: fmt.Sprintf("unit-%02d", index), ProjectID: project.ID, Title: fmt.Sprintf("第%d章", index+1), Position: index, WordCount: 1200, Status: status}
if err := db.Create(&unit).Error; err != nil {
t.Fatal(err)
}
if index < 4 {
if err := db.Create(&model.Shot{ID: fmt.Sprintf("shot-%02d", index), ProjectID: project.ID, UnitID: unit.ID, Position: 0}).Error; err != nil {
t.Fatal(err)
}
}
}
overview, err := service.ProjectOverview("user-1", project.ID)
if err != nil {
t.Fatal(err)
}
if overview.Metrics.UnitCount != 12 || overview.Metrics.CompletedUnitCount != 3 || overview.Metrics.ShotCount != 4 {
t.Fatalf("unexpected overview metrics: %+v", overview.Metrics)
}
if overview.Metrics.TotalWordCount != 14_400 || overview.Metrics.UnitsWithoutShots != 8 {
t.Fatalf("unexpected aggregate totals: %+v", overview.Metrics)
}
if len(overview.Units) != 8 {
t.Fatalf("overview units = %d, want capped 8", len(overview.Units))
}
if overview.Units[0].Unit.SourceText != "" {
t.Fatal("overview unit unexpectedly contains source text")
}
}
func TestProjectUnitWorkspaceIsolatesShotsAndBoundAssetsByUnit(t *testing.T) {
service, db := newProjectWorkbenchReadTestService(t)
project := seedWorkbenchProject(t, db)
unit1 := model.ProjectUnit{ID: "unit-1", ProjectID: project.ID, Title: "第一章", Status: model.ProjectUnitStatusReady}
unit2 := model.ProjectUnit{ID: "unit-2", ProjectID: project.ID, Title: "第二章", Position: 1, Status: model.ProjectUnitStatusReady}
asset1 := model.Asset{ID: "asset-1", UserID: "user-1", Title: "角色甲", Kind: "image", Category: model.AssetCategoryOther, Status: model.AssetVersionStatusConfirmed}
asset2 := model.Asset{ID: "asset-2", UserID: "user-1", Title: "角色乙", Kind: "image", Category: model.AssetCategoryOther, Status: model.AssetVersionStatusConfirmed}
seed := []any{
&unit1, &unit2, &asset1, &asset2,
&model.AssetVersion{ID: "version-1", AssetID: asset1.ID, Version: 1, Status: model.AssetVersionStatusConfirmed},
&model.AssetVersion{ID: "version-2", AssetID: asset2.ID, Version: 1, Status: model.AssetVersionStatusConfirmed},
&model.ProjectAssetLink{ID: "link-1", ProjectID: project.ID, AssetID: asset1.ID},
&model.ProjectAssetLink{ID: "link-2", ProjectID: project.ID, AssetID: asset2.ID},
&model.Shot{ID: "shot-1", ProjectID: project.ID, UnitID: unit1.ID, Position: 0},
&model.Shot{ID: "shot-2", ProjectID: project.ID, UnitID: unit2.ID, Position: 0},
&model.ShotRevision{ID: "revision-1", ShotID: "shot-1", Version: 1},
&model.ShotRevision{ID: "revision-2", ShotID: "shot-2", Version: 1},
&model.ShotArtifact{ID: "artifact-1", ProjectID: project.ID, UnitID: unit1.ID, ShotID: "shot-1", Version: 1},
&model.ShotArtifact{ID: "artifact-2", ProjectID: project.ID, UnitID: unit2.ID, ShotID: "shot-2", Version: 1},
&model.ShotAssetReference{ID: "reference-1", ShotID: "shot-1", AssetVersionID: "version-1", Status: "linked"},
&model.ShotAssetReference{ID: "reference-2", ShotID: "shot-2", AssetVersionID: "version-2", Status: "linked"},
&model.ProjectAssetCandidate{ID: "candidate-1", ProjectID: project.ID, UnitID: unit1.ID, Name: "甲"},
&model.ProjectAssetCandidate{ID: "candidate-2", ProjectID: project.ID, UnitID: unit2.ID, Name: "乙"},
}
for _, item := range seed {
if err := db.Create(item).Error; err != nil {
t.Fatal(err)
}
}
workspace, err := service.ProjectUnitWorkspace("user-1", project.ID, unit1.ID)
if err != nil {
t.Fatal(err)
}
if len(workspace.Shots) != 1 || workspace.Shots[0].ID != "shot-1" || len(workspace.ShotRevisions) != 1 || workspace.ShotRevisions[0].ID != "revision-1" {
t.Fatalf("workspace leaked another unit: shots=%+v revisions=%+v", workspace.Shots, workspace.ShotRevisions)
}
if len(workspace.ShotArtifacts) != 1 || workspace.ShotArtifacts[0].ID != "artifact-1" || len(workspace.ShotReferences) != 1 || workspace.ShotReferences[0].ID != "reference-1" {
t.Fatalf("workspace artifact isolation failed: artifacts=%+v references=%+v", workspace.ShotArtifacts, workspace.ShotReferences)
}
if len(workspace.AssetCandidates) != 1 || workspace.AssetCandidates[0].ID != "candidate-1" || len(workspace.Assets) != 1 || workspace.Assets[0].ID != "asset-1" {
t.Fatalf("workspace asset isolation failed: candidates=%+v assets=%+v", workspace.AssetCandidates, workspace.Assets)
}
}
func TestProjectCanvasesPageReturnsLinksOnlyForCurrentPage(t *testing.T) {
service, db := newProjectWorkbenchReadTestService(t)
project := seedWorkbenchProject(t, db)
if err := db.Create(&model.ProjectUnit{ID: "unit-1", ProjectID: project.ID, Title: "第一章"}).Error; err != nil {
t.Fatal(err)
}
now := time.Now()
for index := 0; index < 5; index++ {
canvasID := fmt.Sprintf("canvas-%d", index)
if err := db.Create(&model.CanvasProject{ID: canvasID, UserID: "user-1", ProjectID: project.ID, Title: canvasID, UpdatedAt: now.Add(time.Duration(index) * time.Minute)}).Error; err != nil {
t.Fatal(err)
}
if err := db.Create(&model.CanvasUnitLink{ID: "link-" + canvasID, ProjectID: project.ID, CanvasID: canvasID, UnitID: "unit-1"}).Error; err != nil {
t.Fatal(err)
}
}
page, err := service.ProjectCanvasesPage("user-1", project.ID, 2, 2)
if err != nil {
t.Fatal(err)
}
if page.Total != 5 || len(page.Canvases) != 2 || len(page.CanvasUnitLinks) != 2 || !page.HasMore {
t.Fatalf("unexpected canvas page: %+v", page)
}
pageIDs := map[string]bool{page.Canvases[0].ID: true, page.Canvases[1].ID: true}
for _, link := range page.CanvasUnitLinks {
if !pageIDs[link.CanvasID] {
t.Fatalf("link %s does not belong to the current canvas page", link.CanvasID)
}
}
units, err := service.ProjectUnitSummaries("user-1", project.ID)
if err != nil {
t.Fatal(err)
}
if units.CanvasCounts["unit-1"] != 5 {
t.Fatalf("unit canvas count = %d, want 5", units.CanvasCounts["unit-1"])
}
}
func TestProjectAssetsPagePaginatesAndReturnsFacets(t *testing.T) {
service, db := newProjectWorkbenchReadTestService(t)
project := seedWorkbenchProject(t, db)
for index := 0; index < 6; index++ {
category := model.AssetCategoryProp
folderID := "folder-b"
if index < 2 {
category = model.AssetCategoryCharacter
folderID = "folder-a"
}
asset := model.Asset{ID: fmt.Sprintf("asset-%d", index), UserID: "user-1", Title: fmt.Sprintf("资产%d", index), Kind: "image", Category: category, Status: model.AssetVersionStatusConfirmed}
if err := db.Create(&asset).Error; err != nil {
t.Fatal(err)
}
if err := db.Create(&model.ProjectAssetLink{ID: fmt.Sprintf("link-%d", index), ProjectID: project.ID, AssetID: asset.ID, FolderID: folderID}).Error; err != nil {
t.Fatal(err)
}
}
page, err := service.ProjectAssetsPage("user-1", project.ID, 2, 2, "prop", "image", "", nil, "")
if err != nil {
t.Fatal(err)
}
if page.Total != 4 || len(page.Assets) != 2 || page.CategoryCounts["character"] != 2 || page.CategoryCounts["prop"] != 4 {
t.Fatalf("unexpected asset page/facets: %+v", page)
}
if page.FolderCounts["folder-a"] != 2 || page.FolderCounts["folder-b"] != 4 {
t.Fatalf("unexpected folder facets: %+v", page.FolderCounts)
}
}