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)
+}

pages/personen.go

@@ -104,11 +104,26 @@ func (p *PersonenPage) FilterRequest(app core.App, engine *templating.Engine, e
 func (p *PersonenPage) SearchRequest(app core.App, engine *templating.Engine, e *core.RequestEvent) error {
 	search := e.Request.URL.Query().Get(PARAM_SEARCH)
 	data := map[string]interface{}{}
+	agents := []*dbmodels.Agent{}
+	altagents := []*dbmodels.Agent{}
 
-	agents, altagents, err := dbmodels.BasicSearchAgents(app, search)
+	a, err := dbmodels.FTS5SearchAgents(app, search)
 	if err != nil {
 		return engine.Response404(e, err, data)
 	}
+	agents = a
+
+	if len(agents) == 0 {
+		// INFO: Fallback to regular search, if FTS5 fails
+		a, aa, err := dbmodels.BasicSearchAgents(app, search)
+		if err != nil {
+			return engine.Response404(e, err, data)
+		}
+		agents = a
+		altagents = aa
+	} else {
+		data["FTS"] = true
+	}
 
 	dbmodels.SortAgentsByName(agents)
 	dbmodels.SortAgentsByName(altagents)

pages/reihen.go

@@ -100,7 +100,7 @@ func (p *ReihenPage) LetterRequest(app core.App, engine *templating.Engine, e *c
 		return engine.Response404(e, err, data)
 	}
 	// INFO: We sort again since the query can't sort german umlauts correctly
-	dbmodels.SortSeriessesByTitle(series)
+	dbmodels.Sort_Series_Title(series)
 	data["series"] = series
 
 	rmap, bmap, err := dbmodels.EntriesForSeriesses(app, series)
@@ -129,7 +129,7 @@ func (p *ReihenPage) PersonRequest(app core.App, engine *templating.Engine, e *c
 	if err != nil {
 		return engine.Response404(e, err, data)
 	}
-	dbmodels.SortSeriessesByTitle(series)
+	dbmodels.Sort_Series_Title(series)
 	data["series"] = series
 	data["relations"] = relations
 	data["entries"] = entries
@@ -172,8 +172,8 @@ func (p *ReihenPage) SearchRequest(app core.App, engine *templating.Engine, e *c
 	if err != nil {
 		return engine.Response404(e, err, data)
 	}
-	dbmodels.SortSeriessesByTitle(series)
-	dbmodels.SortSeriessesByTitle(altseries)
+	dbmodels.Sort_Series_Title(series)
+	dbmodels.Sort_Series_Title(altseries)
 	data["series"] = series
 	data["altseries"] = altseries
 
@@ -208,7 +208,7 @@ func (p *ReihenPage) SearchRequest(app core.App, engine *templating.Engine, e *c
 				return engine.Response404(e, err, data)
 			}
 
-			dbmodels.SortSeriessesByTitle(idseries)
+			dbmodels.Sort_Series_Title(idseries)
 			data["idseries"] = idseries
 
 			if err != nil {

pages/suche.go

@@ -141,7 +141,7 @@ func (p *SuchePage) SimpleSearchReihenRequest(app core.App, engine *templating.E
 		return engine.Response500(e, err, nil)
 	}
 
-	dbmodels.SortSeriessesByTitle(series)
+	dbmodels.Sort_Series_Title(series)
 	data["series"] = series
 	data["relations"] = rmap
 	data["entries"] = bmap