Personen DB Abfragen + Seiten

pages/404.go

@@ -0,0 +1,48 @@
+package pages
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/Theodor-Springmann-Stiftung/musenalm/app"
+	"github.com/Theodor-Springmann-Stiftung/musenalm/pagemodels"
+	"github.com/Theodor-Springmann-Stiftung/musenalm/templating"
+	"github.com/pocketbase/pocketbase/core"
+	"github.com/pocketbase/pocketbase/tools/router"
+)
+
+const URL_ERROR_404 = "/errors/404/"
+
+func init() {
+	rp := &Error404Page{
+		Page: pagemodels.Page{
+			Name: URL_ERROR_404,
+		},
+	}
+	app.Register(rp)
+}
+
+type Error404Page struct {
+	pagemodels.Page
+}
+
+func (p *Error404Page) Setup(router *router.Router[*core.RequestEvent], app core.App, engine *templating.Engine) error {
+	router.GET(URL_ERROR_404, func(e *core.RequestEvent) error {
+		return Error404(e, engine, nil)
+	})
+	return nil
+}
+
+func Error404(e *core.RequestEvent, engine *templating.Engine, err error) error {
+	data := make(map[string]interface{})
+	var sb strings.Builder
+	if err != nil {
+		e.App.Logger().Error("404 error fetching URL!", "error", err, "request", e.Request.URL)
+		data["Error"] = err.Error()
+	}
+	err = engine.Render(&sb, URL_ERROR_404, data, "default")
+	if err != nil {
+		return e.String(http.StatusInternalServerError, err.Error())
+	}
+	return e.HTML(http.StatusNotFound, sb.String())
+}

pages/almanach.go

@@ -0,0 +1,99 @@
+package pages
+
+import (
+	"net/http"
+	"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/pocketbase/core"
+	"github.com/pocketbase/pocketbase/tools/router"
+)
+
+const (
+	URL_ALMANACH      = "/almanach/{id}"
+	TEMPLATE_ALMANACH = "/almanach/"
+)
+
+func init() {
+	rp := &AlmanachPage{
+		Page: pagemodels.Page{
+			Name: pagemodels.P_REIHEN_NAME,
+		},
+	}
+	app.Register(rp)
+}
+
+type AlmanachPage struct {
+	pagemodels.Page
+}
+
+func (p *AlmanachPage) Setup(router *router.Router[*core.RequestEvent], app core.App, engine *templating.Engine) error {
+	router.GET(URL_ALMANACH, func(e *core.RequestEvent) error {
+		id := e.Request.PathValue("id")
+		data := make(map[string]interface{})
+		entry, err := dbmodels.EntryForMusenalmID(app, id)
+		if err != nil {
+			return Error404(e, engine, err)
+		}
+		data["entry"] = entry
+
+		series, srelations, _, err := dbmodels.SeriesForEntries(app, []*dbmodels.Entry{entry})
+		if err != nil {
+			return Error404(e, engine, err)
+		}
+
+		s := map[string]*dbmodels.Series{}
+		for _, r := range series {
+			s[r.Id] = r
+		}
+
+		data["srelations"] = srelations
+		data["series"] = s
+
+		places, err := dbmodels.PlacesForEntry(app, entry)
+		if err != nil {
+			return Error404(e, engine, err)
+		}
+		data["places"] = places
+
+		contents, err := dbmodels.ContentsForEntry(app, entry)
+		if err != nil {
+			return Error404(e, engine, err)
+		}
+		data["contents"] = contents
+
+		agents, arelations, err := dbmodels.AgentsForEntries(app, []*dbmodels.Entry{entry})
+		if err != nil {
+			return Error404(e, engine, err)
+		}
+		data["arelations"] = arelations
+
+		if len(contents) > 0 {
+			cagents, crelations, err := dbmodels.AgentsForContents(app, contents)
+			if err != nil {
+				return Error404(e, engine, err)
+			}
+			data["crelations"] = crelations
+			for k, v := range cagents {
+				agents[k] = v
+			}
+		}
+		data["agents"] = agents
+
+		return p.Get(e, engine, data)
+	})
+
+	return nil
+}
+
+func (p *AlmanachPage) Get(request *core.RequestEvent, engine *templating.Engine, data map[string]interface{}) error {
+	var builder strings.Builder
+	err := engine.Render(&builder, TEMPLATE_ALMANACH, data)
+	if err != nil {
+		return Error404(request, engine, err)
+	}
+	return request.HTML(http.StatusOK, builder.String())
+}

pages/index.go

@@ -24,14 +24,6 @@ type IndexPage struct {
 	pagemodels.Page
 }
 
-func (p *IndexPage) Up(app core.App) error {
-	return nil
-}
-
-func (p *IndexPage) Down(app core.App) error {
-	return nil
-}
-
 func (p *IndexPage) Setup(router *router.Router[*core.RequestEvent], app core.App, engine *templating.Engine) error {
 	router.GET("/{$}", func(e *core.RequestEvent) error {
 		var builder strings.Builder

pages/person.go

@@ -0,0 +1,91 @@
+package pages
+
+import (
+	"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/pocketbase/core"
+	"github.com/pocketbase/pocketbase/tools/router"
+)
+
+const (
+	URL_PERSON      = "/person/{id}"
+	TEMPLATE_PERSON = "/person/"
+)
+
+func init() {
+	rp := &PersonPage{
+		Page: pagemodels.Page{
+			Name: URL_PERSON,
+		},
+	}
+	app.Register(rp)
+}
+
+type PersonPage struct {
+	pagemodels.Page
+}
+
+func (p *PersonPage) Setup(router *router.Router[*core.RequestEvent], app core.App, engine *templating.Engine) error {
+	router.GET(URL_PERSON, func(e *core.RequestEvent) error {
+		person := e.Request.PathValue("id")
+		data := make(map[string]interface{})
+		data[PARAM_PERSON] = person
+
+		agent, err := dbmodels.AgentForId(app, person)
+		if err != nil {
+			return Error404(e, engine, err)
+		}
+		data["a"] = agent
+
+		series, relations, entries, err := dbmodels.SeriesForAgent(app, person)
+		if err != nil {
+			return Error404(e, engine, err)
+		}
+
+		dbmodels.SortSeriessesByTitle(series)
+		data["series"] = series
+		data["relations"] = relations
+		data["entries"] = entries
+
+		contents, err := dbmodels.ContentsForAgent(app, person)
+		if err != nil {
+			return Error404(e, engine, err)
+		}
+
+		agents, crelations, err := dbmodels.AgentsForContents(app, contents)
+		if err != nil {
+			return Error404(e, engine, err)
+		}
+		data["agents"] = agents
+		data["crelations"] = crelations
+
+		centries, err := dbmodels.EntriesForContents(app, contents)
+		if err != nil {
+			return Error404(e, engine, err)
+		}
+		data["centries"] = centries
+
+		dbmodels.SortContentsByEntryNumbering(contents, centries)
+		data["contents"] = contents
+
+		return p.Get(e, engine, data)
+	})
+
+	return nil
+}
+
+func (p *PersonPage) Get(request *core.RequestEvent, engine *templating.Engine, data map[string]interface{}) error {
+	var builder strings.Builder
+	err := engine.Render(&builder, TEMPLATE_PERSON, data)
+	if err != nil {
+		return Error404(request, engine, err)
+	}
+
+	request.Response.Header().Set("Content-Type", "text/html")
+	request.Response.Write([]byte(builder.String()))
+	return nil
+}

pages/personen.go

@@ -0,0 +1,152 @@
+package pages
+
+import (
+	"net/http"
+	"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/pocketbase/core"
+	"github.com/pocketbase/pocketbase/tools/router"
+)
+
+const (
+	URL_PERSONEN = "/personen/"
+	PARAM_FILTER = "filter"
+)
+
+func init() {
+	rp := &PersonenPage{
+		Page: pagemodels.Page{
+			Name: pagemodels.P_REIHEN_NAME,
+		},
+	}
+	app.Register(rp)
+}
+
+type PersonenPage struct {
+	pagemodels.Page
+}
+
+func (p *PersonenPage) Setup(router *router.Router[*core.RequestEvent], app core.App, engine *templating.Engine) error {
+	router.GET(URL_PERSONEN, func(e *core.RequestEvent) error {
+		if e.Request.URL.Query().Get(PARAM_SEARCH) != "" {
+			return p.SearchRequest(app, engine, e)
+		}
+		if e.Request.URL.Query().Get(PARAM_FILTER) != "" {
+			return p.FilterRequest(app, engine, e)
+		}
+
+		return p.LetterRequest(app, engine, e)
+	})
+
+	return nil
+}
+
+func (p *PersonenPage) CommonData(app core.App, data map[string]interface{}) error {
+	letters, err := dbmodels.LettersForAgents(app)
+	if err != nil {
+		return err
+	}
+	data["letters"] = letters
+
+	return nil
+}
+
+func (p *PersonenPage) FilterRequest(app core.App, engine *templating.Engine, e *core.RequestEvent) error {
+	filter := e.Request.URL.Query().Get(PARAM_FILTER)
+	letter := e.Request.URL.Query().Get(PARAM_LETTER)
+	if letter == "" {
+		letter = "A"
+	}
+	data := map[string]interface{}{}
+
+	var err error = nil
+	agents := []*dbmodels.Agent{}
+	if filter == "org" {
+		agents, err = dbmodels.AgentsForOrg(app, true, letter)
+	}
+
+	if filter == "noorg" {
+		agents, err = dbmodels.AgentsForOrg(app, false, letter)
+	}
+
+	if filter == "musik" {
+		agents, err = dbmodels.AgentsForProfession(app, "Musik", letter)
+	}
+
+	if filter == "autor" {
+		agents, err = dbmodels.AgentsForProfession(app, "Text", letter)
+	}
+
+	if filter == "graphik" {
+		agents, err = dbmodels.AgentsForProfession(app, "Graphik", letter)
+	}
+
+	if filter == "hrsg" {
+		agents, err = dbmodels.AgentsForProfession(app, "Hrsg", letter)
+	}
+
+	if err != nil {
+		return Error404(e, engine, err)
+	}
+	dbmodels.SortAgentsByName(agents)
+	data["agents"] = agents
+	data["filter"] = filter
+	data["letter"] = letter
+
+	return p.Get(e, engine, data)
+}
+
+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, altagents, err := dbmodels.BasicSearchAgents(app, search)
+	if err != nil {
+		return Error404(e, engine, err)
+	}
+
+	dbmodels.SortAgentsByName(agents)
+	dbmodels.SortAgentsByName(altagents)
+
+	data["search"] = search
+	data["agents"] = agents
+	data["altagents"] = altagents
+
+	return p.Get(e, engine, data)
+}
+
+func (p *PersonenPage) LetterRequest(app core.App, engine *templating.Engine, e *core.RequestEvent) error {
+	letter := e.Request.URL.Query().Get(PARAM_LETTER)
+	if letter == "" {
+		letter = "A"
+	}
+	data := map[string]interface{}{}
+	data["letter"] = letter
+
+	agents, err := dbmodels.AgentsForLetter(app, letter)
+	if err != nil {
+		return Error404(e, engine, err)
+	}
+	dbmodels.SortAgentsByName(agents)
+	data["agents"] = agents
+
+	return p.Get(e, engine, data)
+}
+
+func (p *PersonenPage) Get(request *core.RequestEvent, engine *templating.Engine, data map[string]interface{}) error {
+	err := p.CommonData(request.App, data)
+	if err != nil {
+		return Error404(request, engine, err)
+	}
+
+	var builder strings.Builder
+	err = engine.Render(&builder, URL_PERSONEN, data)
+	if err != nil {
+		return Error404(request, engine, err)
+	}
+	return request.HTML(http.StatusOK, builder.String())
+}

pages/reihe.go

@@ -36,13 +36,13 @@ func (p *ReihePage) Setup(router *router.Router[*core.RequestEvent], app core.Ap
 		data := make(map[string]interface{})
 		reihe, err := dbmodels.SeriesForId(app, id)
 		if err != nil {
-			return err
+			return Error404(e, engine, err)
 		}
 		data["series"] = reihe
 
 		rmap, emap, err := dbmodels.EntriesForSeriesses(app, []*dbmodels.Series{reihe})
 		if err != nil {
-			return err
+			return Error404(e, engine, err)
 		}
 
 		data["relations"] = rmap
@@ -58,7 +58,7 @@ func (p *ReihePage) Get(request *core.RequestEvent, engine *templating.Engine, d
 	var builder strings.Builder
 	err := engine.Render(&builder, TEMPLATE_REIHE, data)
 	if err != nil {
-		return err
+		return Error404(request, engine, err)
 	}
 	return request.HTML(http.StatusOK, builder.String())
 }

pages/reihen.go

@@ -35,14 +35,6 @@ type ReihenPage struct {
 	pagemodels.Page
 }
 
-func (p *ReihenPage) Up(app core.App) error {
-	return nil
-}
-
-func (p *ReihenPage) Down(app core.App) error {
-	return nil
-}
-
 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)
@@ -64,6 +56,7 @@ func (p *ReihenPage) Setup(router *router.Router[*core.RequestEvent], app core.A
 
 		return p.LetterRequest(app, engine, e)
 	})
+
 	return nil
 }
 
@@ -74,12 +67,12 @@ func (p *ReihenPage) YearRequest(app core.App, engine *templating.Engine, e *cor
 
 	y, err := strconv.Atoi(year)
 	if err != nil {
-		return err
+		return Error404(e, engine, err)
 	}
 
 	series, relations, entries, err := dbmodels.SeriesForYear(app, y)
 	if err != nil {
-		return err
+		return Error404(e, engine, err)
 	}
 	data["entries"] = entries
 	data["relations"] = relations
@@ -98,7 +91,7 @@ func (p *ReihenPage) LetterRequest(app core.App, engine *templating.Engine, e *c
 
 	series, err := dbmodels.SeriesForLetter(app, letter)
 	if err != nil {
-		return err
+		return Error404(e, engine, err)
 	}
 	// INFO: We sort again since the query can't sort german umlauts correctly
 	dbmodels.SortSeriessesByTitle(series)
@@ -106,7 +99,7 @@ func (p *ReihenPage) LetterRequest(app core.App, engine *templating.Engine, e *c
 
 	rmap, bmap, err := dbmodels.EntriesForSeriesses(app, series)
 	if err != nil {
-		return err
+		return Error404(e, engine, err)
 	}
 	data["entries"] = bmap
 	data["relations"] = rmap
@@ -121,14 +114,15 @@ func (p *ReihenPage) PersonRequest(app core.App, engine *templating.Engine, e *c
 
 	agent, err := dbmodels.AgentForId(app, person)
 	if err != nil {
-		return err
+		return Error404(e, engine, err)
 	}
 	data["a"] = agent
 
 	series, relations, entries, err := dbmodels.SeriesForAgent(app, person)
 	if err != nil {
-		return err
+		return Error404(e, engine, err)
 	}
+	dbmodels.SortSeriessesByTitle(series)
 	data["series"] = series
 	data["relations"] = relations
 	data["entries"] = entries
@@ -143,13 +137,13 @@ func (p *ReihenPage) PlaceRequest(app core.App, engine *templating.Engine, e *co
 
 	pl, err := dbmodels.PlaceForId(app, place)
 	if err != nil {
-		return err
+		return Error404(e, engine, err)
 	}
 	data["p"] = pl
 
 	series, relations, entries, err := dbmodels.SeriesForPlace(app, place)
 	if err != nil {
-		return err
+		return Error404(e, engine, err)
 	}
 	data["series"] = series
 	data["relations"] = relations
@@ -164,7 +158,7 @@ func (p *ReihenPage) SearchRequest(app core.App, engine *templating.Engine, e *c
 	data[PARAM_SEARCH] = search
 	series, altseries, err := dbmodels.BasicSearchSeries(app, search)
 	if err != nil {
-		return err
+		return Error404(e, engine, err)
 	}
 	dbmodels.SortSeriessesByTitle(series)
 	dbmodels.SortSeriessesByTitle(altseries)
@@ -173,7 +167,7 @@ func (p *ReihenPage) SearchRequest(app core.App, engine *templating.Engine, e *c
 
 	rmap, bmap, err := dbmodels.EntriesForSeriesses(app, series)
 	if err != nil {
-		return err
+		return Error404(e, engine, err)
 	}
 	data["entries"] = bmap
 	data["relations"] = rmap
@@ -213,7 +207,7 @@ func (p *ReihenPage) CommonData(app core.App, data map[string]interface{}) error
 func (p *ReihenPage) Get(request *core.RequestEvent, engine *templating.Engine, data map[string]interface{}) error {
 	err := p.CommonData(request.App, data)
 	if err != nil {
-		return err
+		return Error404(request, engine, err)
 	}
 
 	var builder strings.Builder