pages -> controllers

controllers/reihen.go

@@ -0,0 +1,569 @@
+package controllers
+
+import (
+	"strconv"
+	"strings"
+
+	"github.com/Theodor-Springmann-Stiftung/musenalm/app"
+	"github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels"
+	"github.com/Theodor-Springmann-Stiftung/musenalm/pagemodels"
+	"github.com/Theodor-Springmann-Stiftung/musenalm/templating"
+	"github.com/pocketbase/dbx"
+	"github.com/pocketbase/pocketbase/core"
+	"github.com/pocketbase/pocketbase/tools/router"
+)
+
+const (
+	URL_REIHEN   = "/reihen/"
+	PARAM_LETTER = "letter"
+	PARAM_SEARCH = "search"
+	PARAM_PERSON = "agent"
+	PARAM_PLACE  = "place"
+	PARAM_YEAR   = "year"
+	PARAM_HIDDEN = "hidden"
+)
+
+func init() {
+	rp := &ReihenPage{
+		DefaultPage: pagemodels.DefaultPage[*pagemodels.DefaultPageRecord]{
+			Name:     pagemodels.P_REIHEN_NAME,
+			URL:      URL_REIHEN,
+			Template: URL_REIHEN,
+			Layout:   templating.DEFAULT_LAYOUT_NAME,
+			Record:   &pagemodels.DefaultPageRecord{},
+		},
+	}
+	app.Register(rp)
+}
+
+type ReihenPage struct {
+	pagemodels.DefaultPage[*pagemodels.DefaultPageRecord]
+}
+
+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 {
+		search := e.Request.URL.Query().Get(PARAM_SEARCH)
+		if search != "" {
+			return p.SearchRequest(app, engine, e)
+		}
+		person := e.Request.URL.Query().Get(PARAM_PERSON)
+		if person != "" {
+			return p.PersonRequest(app, engine, e)
+		}
+		place := e.Request.URL.Query().Get(PARAM_PLACE)
+		if place != "" {
+			return p.PlaceRequest(app, engine, e)
+		}
+		year := e.Request.URL.Query().Get(PARAM_YEAR)
+		if year != "" {
+			return p.YearRequest(app, engine, e)
+		}
+
+		return p.LetterRequest(app, engine, e)
+	})
+
+	return nil
+}
+
+func (p *ReihenPage) YearRequest(app core.App, engine *templating.Engine, e *core.RequestEvent) error {
+	year := e.Request.URL.Query().Get(PARAM_YEAR)
+	data := make(map[string]any)
+	data[PARAM_HIDDEN] = e.Request.URL.Query().Get(PARAM_HIDDEN)
+	data[PARAM_YEAR] = year
+
+	y, err := strconv.Atoi(year)
+	if err != nil {
+		return engine.Response404(e, err, data)
+	}
+
+	result, err := NewSeriesResult_Year(app, y)
+	if err != nil {
+		return engine.Response404(e, err, data)
+	}
+
+	data["result"] = result
+	return p.Get(e, engine, data)
+}
+
+func (p *ReihenPage) LetterRequest(app core.App, engine *templating.Engine, e *core.RequestEvent) error {
+	letter := e.Request.URL.Query().Get(PARAM_LETTER)
+	data := map[string]interface{}{}
+	data[PARAM_HIDDEN] = e.Request.URL.Query().Get(PARAM_HIDDEN)
+	if letter == "" {
+		data["startpage"] = true
+		letter = "A"
+	}
+	data[PARAM_LETTER] = letter
+
+	result, err := NewSeriesListResult_Letter(app, letter)
+	if err != nil {
+		return engine.Response404(e, err, data)
+	}
+
+	data["result"] = result
+	return p.Get(e, engine, data)
+}
+
+func (p *ReihenPage) PersonRequest(app core.App, engine *templating.Engine, e *core.RequestEvent) error {
+	person := e.Request.URL.Query().Get(PARAM_PERSON)
+	data := map[string]interface{}{}
+	data[PARAM_PERSON] = person
+	data[PARAM_HIDDEN] = e.Request.URL.Query().Get(PARAM_HIDDEN)
+
+	result, err := NewSeriesResult_Agent(app, person)
+	if err != nil {
+		return engine.Response404(e, err, data)
+	}
+
+	data["result"] = result
+	return p.Get(e, engine, data)
+}
+
+func (p *ReihenPage) PlaceRequest(app core.App, engine *templating.Engine, e *core.RequestEvent) error {
+	place := e.Request.URL.Query().Get(PARAM_PLACE)
+	data := map[string]interface{}{}
+	data[PARAM_PLACE] = place
+	data[PARAM_HIDDEN] = e.Request.URL.Query().Get(PARAM_HIDDEN)
+
+	result, err := NewSeriesResult_Place(app, place)
+	if err != nil {
+		return engine.Response404(e, err, data)
+	}
+
+	data["result"] = result
+	return p.Get(e, engine, data)
+}
+
+// TODO: Suchverhalten bei gefilterten Personen, Orten und Jahren
+func (p *ReihenPage) SearchRequest(app core.App, engine *templating.Engine, e *core.RequestEvent) error {
+	search := e.Request.URL.Query().Get(PARAM_SEARCH)
+	data := map[string]interface{}{}
+	data[PARAM_SEARCH] = search
+
+	result, err := NewSeriesResult_Search(app, search)
+	if err != nil {
+		return engine.Response404(e, err, data)
+	}
+
+	data["result"] = result
+	return p.Get(e, engine, data)
+}
+
+func (p *ReihenPage) Get(request *core.RequestEvent, engine *templating.Engine, data map[string]interface{}) error {
+	data["common"] = NewCommonReihenData(request.App)
+	record, _ := p.GetLatestData(request.App)
+	if record != nil {
+		data["record"] = pagemodels.NewReihen(record)
+	}
+	return engine.Response200(request, URL_REIHEN, data)
+}
+
+type CommonReihenData struct {
+	Years   []int
+	Places  []*dbmodels.Place
+	Letters []string
+	Agents  []*dbmodels.Agent
+}
+
+func NewCommonReihenData(app core.App) CommonReihenData {
+	arels := []*core.Record{}
+	err := app.RecordQuery(
+		dbmodels.RelationTableName(dbmodels.ENTRIES_TABLE, dbmodels.AGENTS_TABLE)).
+		GroupBy(dbmodels.AGENTS_TABLE).
+		All(&arels)
+	if err != nil {
+		app.Logger().Error("Failed to fetch agents", "error", err)
+	}
+
+	ids := []any{}
+	for _, a := range arels {
+		ids = append(ids, a.GetString(dbmodels.AGENTS_TABLE))
+	}
+
+	agents, err := dbmodels.Agents_IDs(app, ids)
+	if err != nil {
+		app.Logger().Error("Failed to fetch agents", "error", err)
+	}
+
+	letterrecs := []core.Record{}
+	letters := []string{}
+
+	err = app.RecordQuery(dbmodels.SERIES_TABLE).
+		Select("upper(substr(" + dbmodels.SERIES_TITLE_FIELD + ", 1, 1)) AS id").
+		Distinct(true).
+		OrderBy("id").
+		All(&letterrecs)
+	if err != nil {
+		app.Logger().Error("Failed to fetch letters", "error", err)
+	}
+
+	for _, l := range letterrecs {
+		letters = append(letters, l.GetString("id"))
+	}
+
+	places := []*dbmodels.Place{}
+	err = app.RecordQuery(dbmodels.PLACES_TABLE).
+		OrderBy(dbmodels.PLACES_NAME_FIELD).
+		All(&places)
+	if err != nil {
+		app.Logger().Error("Failed to fetch places", "error", err)
+	}
+	dbmodels.Sort_Places_Name(places)
+
+	rec := []core.Record{}
+	err = app.RecordQuery(dbmodels.ENTRIES_TABLE).
+		Select(dbmodels.YEAR_FIELD + " AS id").
+		Distinct(true).
+		OrderBy("id").
+		All(&rec)
+	if err != nil {
+		app.Logger().Error("Failed to fetch years", "error", err)
+	}
+
+	years := []int{}
+	for _, r := range rec {
+		years = append(years, r.GetInt("id"))
+	}
+
+	return CommonReihenData{
+		Years:   years,
+		Places:  places,
+		Letters: letters,
+		Agents:  agents,
+	}
+}
+
+type SeriesListResult struct {
+	Series        []*dbmodels.Series
+	Entries       map[string]*dbmodels.Entry            // <-- Key is Entry.ID
+	EntriesSeries map[string][]*dbmodels.REntriesSeries // <-- Key is Series.ID
+
+	// INFO: Only on agent request
+	Agent         *dbmodels.Agent
+	EntriesAgents map[string][]*dbmodels.REntriesAgents // <-- Key is Entry.ID
+
+	// INFO: Only on search request
+	IDSeries  []*dbmodels.Series
+	AltSeries []*dbmodels.Series
+
+	// INFO: Only on place request
+	Place *dbmodels.Place
+}
+
+func NewSeriesListResult_Letter(app core.App, letter string) (*SeriesListResult, error) {
+	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)
+	if err != nil {
+		return nil, err
+	}
+	dbmodels.Sort_Series_Title(series)
+
+	relations, err := dbmodels.REntriesSeries_Seriess(app, dbmodels.Ids(series))
+	if err != nil {
+		return nil, err
+	}
+
+	eids := []any{}
+	relationsMap := map[string][]*dbmodels.REntriesSeries{}
+	for _, r := range relations {
+		relationsMap[r.Series()] = append(relationsMap[r.Series()], r)
+		eids = append(eids, r.Entry())
+	}
+
+	entries, err := dbmodels.Entries_IDs(app, eids)
+	if err != nil {
+		return nil, err
+	}
+
+	entriesMap := map[string]*dbmodels.Entry{}
+	for _, e := range entries {
+		entriesMap[e.Id] = e
+	}
+
+	for _, r := range relationsMap {
+		dbmodels.Sort_REntriesSeries_Year(r, entriesMap)
+	}
+
+	return &SeriesListResult{
+		Series:        series,
+		Entries:       entriesMap,
+		EntriesSeries: relationsMap,
+	}, nil
+}
+
+func NewSeriesResult_Agent(app core.App, person string) (*SeriesListResult, error) {
+	agent, err := dbmodels.Agents_ID(app, person)
+	if err != nil {
+		return nil, err
+	}
+
+	entriesagentsrels, err := dbmodels.REntriesAgents_Agent(app, agent.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	eids := []any{}
+	entriesagents := map[string][]*dbmodels.REntriesAgents{}
+	for _, r := range entriesagentsrels {
+		eids = append(eids, r.Entry())
+		entriesagents[r.Entry()] = append(entriesagents[r.Entry()], r)
+	}
+
+	entries, err := dbmodels.Entries_IDs(app, eids)
+	if err != nil {
+		return nil, err
+	}
+
+	entriesMap := map[string]*dbmodels.Entry{}
+	for _, e := range entries {
+		entriesMap[e.Id] = e
+	}
+
+	entriesseriesrels, err := dbmodels.REntriesSeries_Entries(app, eids)
+	if err != nil {
+		return nil, err
+	}
+
+	sids := []any{}
+	entriesseries := map[string][]*dbmodels.REntriesSeries{}
+	for _, r := range entriesseriesrels {
+		sids = append(sids, r.Series())
+		entriesseries[r.Series()] = append(entriesseries[r.Series()], r)
+	}
+
+	series, err := dbmodels.Series_IDs(app, sids)
+	if err != nil {
+		return nil, err
+	}
+
+	dbmodels.Sort_Series_Title(series)
+
+	return &SeriesListResult{
+		Series:        series,
+		Entries:       entriesMap,
+		EntriesSeries: entriesseries,
+		Agent:         agent,
+		EntriesAgents: entriesagents,
+	}, nil
+}
+
+func NewSeriesResult_Year(app core.App, year int) (*SeriesListResult, error) {
+	entries := []*dbmodels.Entry{}
+	err := app.RecordQuery(dbmodels.ENTRIES_TABLE).
+		Where(dbx.HashExp{dbmodels.YEAR_FIELD: year}).
+		All(&entries)
+	if err != nil {
+		return nil, err
+	}
+
+	entriesMap := map[string]*dbmodels.Entry{}
+	eids := []any{}
+	for _, e := range entries {
+		eids = append(eids, e.Id)
+		entriesMap[e.Id] = e
+	}
+
+	entriesseriesrels, err := dbmodels.REntriesSeries_Entries(app, eids)
+	if err != nil {
+		return nil, err
+	}
+
+	sids := []any{}
+	entriesseries := map[string][]*dbmodels.REntriesSeries{}
+	for _, r := range entriesseriesrels {
+		sids = append(sids, r.Series())
+		entriesseries[r.Series()] = append(entriesseries[r.Series()], r)
+	}
+
+	series, err := dbmodels.Series_IDs(app, sids)
+	if err != nil {
+		return nil, err
+	}
+
+	dbmodels.Sort_Series_Title(series)
+
+	return &SeriesListResult{
+		Series:        series,
+		Entries:       entriesMap,
+		EntriesSeries: entriesseries,
+	}, nil
+}
+
+func NewSeriesResult_Place(app core.App, place string) (*SeriesListResult, error) {
+	p, err := dbmodels.Places_ID(app, place)
+	if err != nil {
+		return nil, err
+	}
+
+	entries := []*dbmodels.Entry{}
+	err = app.RecordQuery(dbmodels.ENTRIES_TABLE).
+		Where(dbx.Like(dbmodels.PLACES_TABLE, place).Match(true, true)).
+		All(&entries)
+	if err != nil {
+		return nil, err
+	}
+
+	entriesMap := map[string]*dbmodels.Entry{}
+	eids := []any{}
+	for _, e := range entries {
+		eids = append(eids, e.Id)
+		entriesMap[e.Id] = e
+	}
+
+	entriesseriesrels, err := dbmodels.REntriesSeries_Entries(app, eids)
+	if err != nil {
+		return nil, err
+	}
+
+	sids := []any{}
+	entriesseries := map[string][]*dbmodels.REntriesSeries{}
+	for _, r := range entriesseriesrels {
+		sids = append(sids, r.Series())
+		entriesseries[r.Series()] = append(entriesseries[r.Series()], r)
+	}
+
+	series, err := dbmodels.Series_IDs(app, sids)
+	if err != nil {
+		return nil, err
+	}
+
+	dbmodels.Sort_Series_Title(series)
+
+	return &SeriesListResult{
+		Series:        series,
+		Entries:       entriesMap,
+		EntriesSeries: entriesseries,
+		Place:         p,
+	}, nil
+}
+
+func NewSeriesResult_Search(app core.App, search string) (*SeriesListResult, error) {
+	series, altseries, err := dbmodels.BasicSearchSeries(app, search)
+	if err != nil {
+		return nil, err
+	}
+
+	dbmodels.Sort_Series_Title(series)
+	dbmodels.Sort_Series_Title(altseries)
+
+	keys := []any{}
+	keys = append(keys, dbmodels.Ids(series)...)
+	keys = append(keys, dbmodels.Ids(altseries)...)
+
+	entries, relations, err := Entries_Series_IDs(app, keys)
+	if err != nil {
+		return nil, err
+	}
+
+	relationsMap := make(map[string][]*dbmodels.REntriesSeries)
+	entriesMap := make(map[string]*dbmodels.Entry)
+	for _, v := range relations {
+		relationsMap[v.Series()] = append(relationsMap[v.Series()], v)
+	}
+
+	for _, v := range entries {
+		entriesMap[v.Id] = v
+	}
+
+	ret := &SeriesListResult{
+		Series:        series,
+		AltSeries:     altseries,
+		Entries:       entriesMap,
+		EntriesSeries: relationsMap,
+	}
+
+	if _, err := strconv.Atoi(strings.TrimSpace(search)); err == nil {
+		identries := []*dbmodels.Entry{}
+		err := app.RecordQuery(dbmodels.ENTRIES_TABLE).
+			Where(dbx.HashExp{dbmodels.MUSENALMID_FIELD: search}).
+			All(&identries)
+		if err != nil {
+			return nil, err
+		}
+
+		if len(identries) != 0 {
+			app.Logger().Info("Found entries by musenalmid", "count", len(identries))
+			idseries, idrelations, err := Series_Entries(app, identries)
+			if err != nil {
+				return nil, err
+			}
+
+			dbmodels.Sort_Series_Title(idseries)
+			ret.IDSeries = idseries
+
+			for _, v := range idrelations {
+				ret.EntriesSeries[v.Series()] = append(relationsMap[v.Series()], v)
+			}
+
+			for _, v := range identries {
+				ret.Entries[v.Id] = v
+			}
+		}
+	}
+
+	return ret, nil
+}
+
+func (r *SeriesListResult) Count() int {
+	return len(r.Series) + len(r.AltSeries) + len(r.IDSeries)
+}
+
+func Entries_Series(app core.App, series []*dbmodels.Series) ([]*dbmodels.Entry, []*dbmodels.REntriesSeries, error) {
+	relations, err := dbmodels.REntriesSeries_Seriess(app, dbmodels.Ids(series))
+	if err != nil {
+		return nil, nil, err
+	}
+
+	eids := []any{}
+	for _, r := range relations {
+		eids = append(eids, r.Entry())
+	}
+
+	entries, err := dbmodels.Entries_IDs(app, eids)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return entries, relations, nil
+}
+
+func Entries_Series_IDs(app core.App, ids []any) ([]*dbmodels.Entry, []*dbmodels.REntriesSeries, error) {
+	relations, err := dbmodels.REntriesSeries_Seriess(app, ids)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	eids := []any{}
+	for _, r := range relations {
+		eids = append(eids, r.Entry())
+	}
+
+	entries, err := dbmodels.Entries_IDs(app, eids)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return entries, relations, nil
+}
+
+func Series_Entries(app core.App, entries []*dbmodels.Entry) ([]*dbmodels.Series, []*dbmodels.REntriesSeries, error) {
+	relations, err := dbmodels.REntriesSeries_Entries(app, dbmodels.Ids(entries))
+	if err != nil {
+		return nil, nil, err
+	}
+
+	sids := []any{}
+	for _, r := range relations {
+		sids = append(sids, r.Series())
+	}
+
+	series, err := dbmodels.Series_IDs(app, sids)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return series, relations, nil
+}