Allerhand Kleinigkeiten; Einzelansichten Reihen u Personen; Bandansicht

pages/person.go

@@ -1,6 +1,8 @@
 package pages
 
 import (
+	"database/sql"
+
 	"github.com/Theodor-Springmann-Stiftung/musenalm/app"
 	"github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels"
 	"github.com/Theodor-Springmann-Stiftung/musenalm/pagemodels"
@@ -36,45 +38,164 @@ func (p *PersonPage) Setup(router *router.Router[*core.RequestEvent], app core.A
 		data := make(map[string]interface{})
 		data[PARAM_PERSON] = person
 
-		agent, err := dbmodels.AgentForId(app, person)
+		result, err := NewAgentResult(app, person)
 		if err != nil {
 			return engine.Response404(e, err, data)
 		}
-		data["a"] = agent
-
-		series, relations, entries, err := dbmodels.SeriesForAgent(app, person)
-		if err != nil {
-			return engine.Response404(e, err, data)
-		}
-
-		dbmodels.SortSeriessesByTitle(series)
-		data["series"] = series
-		data["relations"] = relations
-		data["entries"] = entries
-
-		contents, err := dbmodels.ContentsForAgent(app, person)
-		if err != nil {
-			return engine.Response404(e, err, data)
-		}
-
-		agents, crelations, err := dbmodels.AgentsForContents(app, contents)
-		if err != nil {
-			return engine.Response404(e, err, data)
-		}
-		data["agents"] = agents
-		data["crelations"] = crelations
-
-		centries, err := dbmodels.EntriesForContents(app, contents)
-		if err != nil {
-			return engine.Response404(e, err, data)
-		}
-		data["centries"] = centries
-
-		dbmodels.SortContentsByEntryNumbering(contents, centries)
-		data["contents"] = contents
+		data["result"] = result
 
 		return engine.Response200(e, p.Template, data, p.Layout)
 	})
 
 	return nil
 }
+
+type AgentResult struct {
+	Agent *dbmodels.Agent
+
+	BResult       []*dbmodels.Series                    // Sorted
+	Entries       map[string]*dbmodels.Entry            // KEY: Entry ID
+	EntriesSeries map[string][]*dbmodels.REntriesSeries // KEY: Series ID
+	EntriesAgents map[string][]*dbmodels.REntriesAgents // KEY: Entry ID
+
+	// INFO: we could save a DB query by quering the entries table only once
+	CResult        []*dbmodels.Entry                      /// Sorted
+	Contents       map[string][]*dbmodels.Content         // KEY: entry ID
+	ContentsAgents map[string][]*dbmodels.RContentsAgents // KEY: Content ID
+}
+
+func NewAgentResult(app core.App, id string) (*AgentResult, error) {
+	agent, err := dbmodels.AgentForId(app, id)
+	if err != nil {
+		return nil, err
+	}
+
+	res := &AgentResult{
+		Agent: agent,
+	}
+
+	err = res.FilterEntriesByPerson(app, id, res)
+	if err != nil {
+		return nil, err
+	}
+
+	return res, nil
+}
+
+func (p *AgentResult) FilterEntriesByPerson(app core.App, id string, res *AgentResult) error {
+	// 1. DB Hit
+	relations, err := dbmodels.REntriesAgents_Agent(app, id)
+	if err != nil && err != sql.ErrNoRows {
+		return err
+	}
+
+	if len(relations) == 0 {
+		return nil
+	}
+
+	entriesagents := make(map[string][]*dbmodels.REntriesAgents)
+	entryIds := []any{}
+	for _, r := range relations {
+		entryIds = append(entryIds, r.Entry())
+		entriesagents[r.Entry()] = append(entriesagents[r.Entry()], r)
+	}
+	res.EntriesAgents = entriesagents
+
+	// 2. DB Hit
+	entries, err := dbmodels.Entries_IDs(app, entryIds)
+	if err != nil {
+		return err
+	}
+
+	entryMap := make(map[string]*dbmodels.Entry, len(entries))
+	for _, e := range entries {
+		entryMap[e.Id] = e
+	}
+	res.Entries = entryMap
+
+	// 3. DB Hit
+	entriesseries, err := dbmodels.REntriesSeries_Entries(app, entryIds)
+	if err != nil {
+		return err
+	}
+	entriesseriesmap := make(map[string][]*dbmodels.REntriesSeries, len(entriesseries))
+	for _, r := range entriesseries {
+		entriesseriesmap[r.Series()] = append(entriesseriesmap[r.Series()], r)
+	}
+
+	for _, r := range entriesseriesmap {
+		dbmodels.Sort_REntriesSeries_Year(r, entryMap)
+	}
+
+	res.EntriesSeries = entriesseriesmap
+
+	seriesIds := []any{}
+	for _, s := range entriesseries {
+		seriesIds = append(seriesIds, s.Series())
+	}
+
+	// 4. DB Hit
+	series, err := dbmodels.Series_IDs(app, seriesIds)
+	if err != nil {
+		return err
+	}
+
+	res.BResult = series
+
+	return nil
+}
+
+func (p *AgentResult) FilterContentsByEntry(app core.App, id string, res *AgentResult) error {
+	// 1. DB Hit
+	relations, err := dbmodels.RContentsAgents_Agent(app, id)
+	if err != nil && err != sql.ErrNoRows {
+		return err
+	}
+
+	if len(relations) == 0 {
+		return nil
+	}
+
+	contentsagents := make(map[string][]*dbmodels.RContentsAgents)
+	contentIds := []any{}
+	for _, r := range relations {
+		contentIds = append(contentIds, r.Content())
+		contentsagents[r.Content()] = append(contentsagents[r.Content()], r)
+	}
+	res.ContentsAgents = contentsagents
+
+	// 2. DB Hit
+	contents, err := dbmodels.Contents_IDs(app, contentIds)
+	if err != nil {
+		return err
+	}
+
+	contentMap := make(map[string][]*dbmodels.Content, len(contents))
+	entrykeys := []any{}
+	for _, c := range contents {
+		contentMap[c.Entry()] = append(contentMap[c.Entry()], c)
+		entrykeys = append(entrykeys, c.Entry())
+	}
+	res.Contents = contentMap
+
+	// 3. DB Hit
+	entries, err := dbmodels.Entries_IDs(app, entrykeys)
+	if err != nil {
+		return err
+	}
+	res.CResult = entries
+
+	return nil
+}
+
+func (p *AgentResult) LenEntries() int {
+	return len(p.Entries)
+}
+
+func (p *AgentResult) LenSeries() int {
+	return len(p.BResult)
+}
+
+func (p *AgentResult) LenContents() int {
+	return len(p.Contents)
+}