Reihen Page -- all kinds of stuff

pages/reihen.go

@@ -1,8 +1,8 @@
 package pages
 
 import (
-	"fmt"
 	"net/http"
+	"slices"
 	"strings"
 
 	"github.com/Theodor-Springmann-Stiftung/musenalm/app"
@@ -17,6 +17,7 @@ import (
 const (
 	URL_REIHEN   = "/reihen/"
 	PARAM_LETTER = "letter"
+	PARAM_SEARCH = "search"
 )
 
 func init() {
@@ -42,34 +43,183 @@ func (p *ReihenPage) Down(app core.App) error {
 
 func (p *ReihenPage) Setup(router *router.Router[*core.RequestEvent], app core.App, engine *templating.Engine) error {
 	router.GET(URL_REIHEN, func(e *core.RequestEvent) error {
-		letter := e.Request.URL.Query().Get(PARAM_LETTER)
-		if letter == "" {
-			letter = "A"
+		search := e.Request.URL.Query().Get(PARAM_SEARCH)
+		if search != "" {
+			return p.SearchRequest(app, engine, e)
 		}
 
-		series := []*dbmodels.Series{}
-		err := app.RecordQuery(dbmodels.SERIES_TABLE).
-			AndWhere(dbx.NewExp(dbmodels.SERIES_TITLE_FIELD + " LIKE '" + letter + "%'")).
-			OrderBy(dbmodels.SERIES_TITLE_FIELD).
-			All(&series)
-		// INFO: this does not return an error if the result set is empty
-		if err != nil {
-			return err
-		}
-
-		// INFO: We sort again since the query can't sort german umlauts correctly
-		dbmodels.SortSeriesByTitle(series)
-
-		var builder strings.Builder
-		err = engine.Render(&builder, URL_REIHEN, map[string]interface{}{
-			PARAM_LETTER: letter,
-			"series":     series,
-		})
-		if err != nil {
-			return err
-		}
-
-		return e.HTML(http.StatusOK, builder.String())
+		return p.LetterRequest(app, engine, e)
 	})
 	return nil
 }
+
+func (p *ReihenPage) LetterRequest(app core.App, engine *templating.Engine, e *core.RequestEvent) error {
+	letter := e.Request.URL.Query().Get(PARAM_LETTER)
+	if letter == "" {
+		letter = "A"
+	}
+	series := []*dbmodels.Series{}
+	err := app.RecordQuery(dbmodels.SERIES_TABLE).
+		Where(dbx.Like(dbmodels.SERIES_TITLE_FIELD, letter).Match(false, true)).
+		OrderBy(dbmodels.SERIES_TITLE_FIELD).
+		All(&series)
+	// INFO: this does not return an error if the result set is empty
+	if err != nil {
+		return err
+	}
+
+	// INFO: We sort again since the query can't sort german umlauts correctly
+	dbmodels.SortSeriesByTitle(series)
+
+	smap, bmap := p.EntriesForSeries(app, series)
+	agents, _ := p.GetAgents(app)
+
+	var builder strings.Builder
+	err = engine.Render(&builder, URL_REIHEN, map[string]interface{}{
+		PARAM_LETTER: letter,
+		"series":     series,
+		"letters":    p.Letters(app),
+		"entries":    bmap,
+		"relations":  smap,
+		"agents":     agents,
+	})
+	if err != nil {
+		return err
+	}
+
+	return e.HTML(http.StatusOK, builder.String())
+}
+
+func (p *ReihenPage) SearchRequest(app core.App, engine *templating.Engine, e *core.RequestEvent) error {
+	search := e.Request.URL.Query().Get(PARAM_SEARCH)
+	series := []*dbmodels.Series{}
+	err := app.RecordQuery(dbmodels.SERIES_TABLE).
+		Where(dbx.Like(dbmodels.SERIES_TITLE_FIELD, search).Match(true, true)).
+		OrderBy(dbmodels.SERIES_TITLE_FIELD).
+		All(&series)
+	if err != nil {
+		return err
+	}
+
+	altseries := []*dbmodels.Series{}
+	err = app.RecordQuery(dbmodels.SERIES_TABLE).
+		Where(dbx.Like(dbmodels.ANNOTATION_FIELD, search).Match(true, true)).
+		OrderBy(dbmodels.SERIES_TITLE_FIELD).
+		All(&altseries)
+	if err != nil {
+		return err
+	}
+
+	dbmodels.SortSeriesByTitle(series)
+	dbmodels.SortSeriesByTitle(altseries)
+
+	smap, bmap := p.EntriesForSeries(app, series)
+	agents, _ := p.GetAgents(app)
+
+	var builder strings.Builder
+	err = engine.Render(&builder, URL_REIHEN, map[string]interface{}{
+		PARAM_SEARCH: search,
+		"series":     series,
+		"altseries":  altseries,
+		"letters":    p.Letters(app),
+		"entries":    bmap,
+		"relations":  smap,
+		"agents":     agents,
+	})
+	if err != nil {
+		return err
+	}
+
+	return e.HTML(http.StatusOK, builder.String())
+}
+
+func (p *ReihenPage) Letters(app core.App) []string {
+	letters := []core.Record{}
+	ids := []string{}
+
+	err := app.RecordQuery(dbmodels.SERIES_TABLE).
+		Select("upper(substr(" + dbmodels.SERIES_TITLE_FIELD + ", 1, 1)) AS id").
+		Distinct(true).
+		All(&letters)
+	if err != nil {
+		return ids
+	}
+
+	for _, l := range letters {
+		ids = append(ids, l.GetString("id"))
+	}
+	return ids
+}
+
+func (p *ReihenPage) EntriesForSeries(app core.App, series []*dbmodels.Series) (
+	map[string][]*dbmodels.REntriesSeries,
+	map[string]*dbmodels.Entry) {
+	ids := []any{}
+	for _, s := range series {
+		ids = append(ids, s.Id)
+	}
+
+	relations := []*core.Record{}
+
+	err := app.RecordQuery(dbmodels.RelationTableName(dbmodels.ENTRIES_TABLE, dbmodels.SERIES_TABLE)).
+		Where(dbx.HashExp{
+			dbmodels.SERIES_TABLE: ids,
+		}).
+		All(&relations)
+	if err != nil {
+		return nil, nil
+	}
+
+	app.ExpandRecords(relations, []string{dbmodels.ENTRIES_TABLE}, nil)
+	bmap := map[string]*dbmodels.Entry{}
+	for _, r := range relations {
+		record := r.ExpandedOne(dbmodels.ENTRIES_TABLE)
+		if record == nil {
+			continue
+		}
+		entry := dbmodels.NewEntry(record)
+		bmap[entry.Id] = entry
+	}
+
+	smap := map[string][]*dbmodels.REntriesSeries{}
+	for _, r := range relations {
+		series := dbmodels.NewREntriesSeries(r)
+		smap[series.Id] = append(smap[series.Id], series)
+	}
+
+	for _, rel := range smap {
+		slices.SortFunc(rel, func(i, j *dbmodels.REntriesSeries) int {
+			ientry := bmap[i.Entry()]
+			jentry := bmap[j.Entry()]
+			return ientry.Year() - jentry.Year()
+		})
+	}
+
+	return smap, bmap
+}
+
+func (p *ReihenPage) GetAgents(app core.App) ([]*dbmodels.Agent, error) {
+	rels := []*core.Record{}
+	// INFO: we could just fetch all relations here
+	err := app.RecordQuery(dbmodels.RelationTableName(dbmodels.ENTRIES_TABLE, dbmodels.AGENTS_TABLE)).
+		GroupBy(dbmodels.AGENTS_TABLE).
+		All(&rels)
+	if err != nil {
+		return nil, err
+	}
+
+	app.ExpandRecords(rels, []string{dbmodels.AGENTS_TABLE}, nil)
+	agents := []*dbmodels.Agent{}
+	for _, r := range rels {
+		record := r.ExpandedOne(dbmodels.AGENTS_TABLE)
+		if record == nil {
+			continue
+		}
+		agent := dbmodels.NewAgent(record)
+		agents = append(agents, agent)
+	}
+
+	dbmodels.SortAgentsByName(agents)
+
+	return agents, err
+}