mirror of
https://github.com/Theodor-Springmann-Stiftung/musenalm.git
synced 2026-02-04 02:25:30 +00:00
408 lines
12 KiB
Go
408 lines
12 KiB
Go
package controllers
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
"net/url"
|
|
"slices"
|
|
"strings"
|
|
|
|
"github.com/Theodor-Springmann-Stiftung/musenalm/app"
|
|
"github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels"
|
|
"github.com/Theodor-Springmann-Stiftung/musenalm/middleware"
|
|
"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"
|
|
"github.com/pocketbase/pocketbase/tools/types"
|
|
)
|
|
|
|
const (
|
|
URL_REIHE_EDIT = "edit"
|
|
URL_REIHE_DELETE = "edit/delete"
|
|
TEMPLATE_REIHE_EDIT = "/reihe/edit/"
|
|
)
|
|
|
|
func init() {
|
|
rep := &ReiheEditPage{
|
|
StaticPage: pagemodels.StaticPage{
|
|
Name: pagemodels.P_REIHE_EDIT_NAME,
|
|
URL: URL_REIHE_EDIT,
|
|
Template: TEMPLATE_REIHE_EDIT,
|
|
Layout: pagemodels.LAYOUT_LOGIN_PAGES,
|
|
},
|
|
}
|
|
app.Register(rep)
|
|
}
|
|
|
|
type ReiheEditPage struct {
|
|
pagemodels.StaticPage
|
|
}
|
|
|
|
func (p *ReiheEditPage) Setup(router *router.Router[*core.RequestEvent], app core.App, engine *templating.Engine) error {
|
|
rg := router.Group(URL_REIHE)
|
|
rg.BindFunc(middleware.IsAdminOrEditor())
|
|
rg.GET(URL_REIHE_EDIT, p.GET(engine, app))
|
|
rg.POST(URL_REIHE_EDIT, p.POST(engine, app))
|
|
rg.POST(URL_REIHE_DELETE, p.POSTDelete(engine, app))
|
|
return nil
|
|
}
|
|
|
|
type ReiheEditResult struct {
|
|
Series *dbmodels.Series
|
|
User *dbmodels.User
|
|
Prev *dbmodels.Series
|
|
Next *dbmodels.Series
|
|
Entries []*dbmodels.Entry
|
|
Contents []*dbmodels.Content
|
|
ContentEntries map[string]*dbmodels.Entry
|
|
ContentTypes map[string][]string
|
|
PreferredEntries []*dbmodels.Entry
|
|
}
|
|
|
|
func NewReiheEditResult(app core.App, id string) (*ReiheEditResult, error) {
|
|
series, err := dbmodels.Series_MusenalmID(app, id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var user *dbmodels.User
|
|
if series.Editor() != "" {
|
|
u, err := dbmodels.Users_ID(app, series.Editor())
|
|
if err == nil {
|
|
user = u
|
|
} else {
|
|
app.Logger().Error("Failed to load user for series editor", "series", series.Id, "error", err)
|
|
}
|
|
}
|
|
|
|
prev, next, err := seriesNeighbors(app, series.Id)
|
|
if err != nil {
|
|
app.Logger().Error("Failed to load series neighbors", "series", series.Id, "error", err)
|
|
}
|
|
|
|
entries, _, err := Entries_Series_IDs(app, []any{series.Id})
|
|
if err != nil {
|
|
app.Logger().Error("Failed to load series entries", "series", series.Id, "error", err)
|
|
}
|
|
if len(entries) > 0 {
|
|
dbmodels.Sort_Entries_Year_Title(entries)
|
|
}
|
|
|
|
contents, contentEntries, contentTypes, err := seriesContentsDetails(app, entries)
|
|
if err != nil {
|
|
app.Logger().Error("Failed to load series contents", "series", series.Id, "error", err)
|
|
}
|
|
if len(contents) > 0 {
|
|
dbmodels.Sort_Contents_Numbering(contents)
|
|
}
|
|
|
|
preferredEntries, err := preferredSeriesEntries(app, series.Id)
|
|
if err != nil {
|
|
app.Logger().Error("Failed to load preferred series entries", "series", series.Id, "error", err)
|
|
}
|
|
if len(preferredEntries) > 0 {
|
|
dbmodels.Sort_Entries_Year_Title(preferredEntries)
|
|
}
|
|
|
|
return &ReiheEditResult{
|
|
Series: series,
|
|
User: user,
|
|
Prev: prev,
|
|
Next: next,
|
|
Entries: entries,
|
|
Contents: contents,
|
|
ContentEntries: contentEntries,
|
|
ContentTypes: contentTypes,
|
|
PreferredEntries: preferredEntries,
|
|
}, nil
|
|
}
|
|
|
|
func (p *ReiheEditPage) GET(engine *templating.Engine, app core.App) HandleFunc {
|
|
return func(e *core.RequestEvent) error {
|
|
id := e.Request.PathValue("id")
|
|
data := make(map[string]any)
|
|
result, err := NewReiheEditResult(app, id)
|
|
if err != nil {
|
|
return engine.Response404(e, err, data)
|
|
}
|
|
data["result"] = result
|
|
|
|
req := templating.NewRequest(e)
|
|
data["csrf_token"] = req.Session().Token
|
|
|
|
if msg := e.Request.URL.Query().Get("saved_message"); msg != "" {
|
|
data["success"] = msg
|
|
}
|
|
|
|
return engine.Response200(e, p.Template, data, p.Layout)
|
|
}
|
|
}
|
|
|
|
func (p *ReiheEditPage) renderError(engine *templating.Engine, app core.App, e *core.RequestEvent, message string) error {
|
|
id := e.Request.PathValue("id")
|
|
data := make(map[string]any)
|
|
result, err := NewReiheEditResult(app, id)
|
|
if err != nil {
|
|
return engine.Response404(e, err, data)
|
|
}
|
|
data["result"] = result
|
|
data["error"] = message
|
|
|
|
req := templating.NewRequest(e)
|
|
data["csrf_token"] = req.Session().Token
|
|
|
|
return engine.Response200(e, p.Template, data, p.Layout)
|
|
}
|
|
|
|
type reiheDeletePayload struct {
|
|
CSRFToken string `json:"csrf_token"`
|
|
LastEdited string `json:"last_edited"`
|
|
}
|
|
|
|
func (p *ReiheEditPage) POSTDelete(engine *templating.Engine, app core.App) HandleFunc {
|
|
return func(e *core.RequestEvent) error {
|
|
id := e.Request.PathValue("id")
|
|
req := templating.NewRequest(e)
|
|
|
|
payload := reiheDeletePayload{}
|
|
if err := e.BindBody(&payload); err != nil {
|
|
return e.JSON(http.StatusBadRequest, map[string]any{
|
|
"error": "Ungültige Formulardaten.",
|
|
})
|
|
}
|
|
|
|
if err := req.CheckCSRF(payload.CSRFToken); err != nil {
|
|
return e.JSON(http.StatusBadRequest, map[string]any{
|
|
"error": err.Error(),
|
|
})
|
|
}
|
|
|
|
series, err := dbmodels.Series_MusenalmID(app, id)
|
|
if err != nil {
|
|
return e.JSON(http.StatusNotFound, map[string]any{
|
|
"error": "Reihe wurde nicht gefunden.",
|
|
})
|
|
}
|
|
|
|
if payload.LastEdited != "" {
|
|
lastEdited, err := types.ParseDateTime(payload.LastEdited)
|
|
if err != nil {
|
|
return e.JSON(http.StatusBadRequest, map[string]any{
|
|
"error": "Ungültiger Bearbeitungszeitstempel.",
|
|
})
|
|
}
|
|
if !series.Updated().Time().Equal(lastEdited.Time()) {
|
|
return e.JSON(http.StatusConflict, map[string]any{
|
|
"error": "Die Reihe wurde inzwischen geändert. Bitte Seite neu laden.",
|
|
})
|
|
}
|
|
}
|
|
|
|
preferredEntries, err := preferredSeriesEntries(app, series.Id)
|
|
if err != nil {
|
|
return e.JSON(http.StatusInternalServerError, map[string]any{
|
|
"error": "Löschen fehlgeschlagen.",
|
|
})
|
|
}
|
|
|
|
if err := app.RunInTransaction(func(tx core.App) error {
|
|
for _, entry := range preferredEntries {
|
|
if err := deleteEntryRelations(tx, entry.Id); err != nil {
|
|
return err
|
|
}
|
|
if err := deleteEntryItems(tx, entry.Id); err != nil {
|
|
return err
|
|
}
|
|
if err := deleteEntryContents(tx, entry.Id); err != nil {
|
|
return err
|
|
}
|
|
record, err := tx.FindRecordById(dbmodels.ENTRIES_TABLE, entry.Id)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
if err := tx.Delete(record); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
relations, err := dbmodels.REntriesSeries_Seriess(tx, []any{series.Id})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
relationsTable := dbmodels.RelationTableName(dbmodels.ENTRIES_TABLE, dbmodels.SERIES_TABLE)
|
|
for _, relation := range relations {
|
|
record, err := tx.FindRecordById(relationsTable, relation.Id)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
if err := tx.Delete(record); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
record, err := tx.FindRecordById(dbmodels.SERIES_TABLE, series.Id)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return tx.Delete(record)
|
|
}); err != nil {
|
|
app.Logger().Error("Failed to delete series", "series_id", series.Id, "error", err)
|
|
return e.JSON(http.StatusInternalServerError, map[string]any{
|
|
"error": "Löschen fehlgeschlagen.",
|
|
})
|
|
}
|
|
|
|
return e.JSON(http.StatusOK, map[string]any{
|
|
"success": true,
|
|
"redirect": "/reihen",
|
|
})
|
|
}
|
|
}
|
|
|
|
func seriesNeighbors(app core.App, currentID string) (*dbmodels.Series, *dbmodels.Series, error) {
|
|
series := []*dbmodels.Series{}
|
|
if err := app.RecordQuery(dbmodels.SERIES_TABLE).All(&series); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
if len(series) == 0 {
|
|
return nil, nil, nil
|
|
}
|
|
dbmodels.Sort_Series_Title(series)
|
|
for index, item := range series {
|
|
if item.Id != currentID {
|
|
continue
|
|
}
|
|
var prev *dbmodels.Series
|
|
var next *dbmodels.Series
|
|
if index > 0 {
|
|
prev = series[index-1]
|
|
}
|
|
if index+1 < len(series) {
|
|
next = series[index+1]
|
|
}
|
|
return prev, next, nil
|
|
}
|
|
return nil, nil, nil
|
|
}
|
|
|
|
func seriesContentsDetails(app core.App, entries []*dbmodels.Entry) ([]*dbmodels.Content, map[string]*dbmodels.Entry, map[string][]string, error) {
|
|
if len(entries) == 0 {
|
|
return []*dbmodels.Content{}, map[string]*dbmodels.Entry{}, map[string][]string{}, nil
|
|
}
|
|
entryMap := make(map[string]*dbmodels.Entry, len(entries))
|
|
for _, entry := range entries {
|
|
entryMap[entry.Id] = entry
|
|
}
|
|
|
|
contents := []*dbmodels.Content{}
|
|
typeMap := make(map[string][]string)
|
|
for _, entry := range entries {
|
|
entryContents, err := dbmodels.Contents_Entry(app, entry.Id)
|
|
if err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
for _, content := range entryContents {
|
|
contents = append(contents, content)
|
|
typeMap[content.Id] = append(typeMap[content.Id], content.MusenalmType()...)
|
|
}
|
|
}
|
|
|
|
return contents, entryMap, typeMap, nil
|
|
}
|
|
|
|
func preferredSeriesEntries(app core.App, seriesID string) ([]*dbmodels.Entry, error) {
|
|
relations, err := dbmodels.REntriesSeries_Seriess(app, []any{seriesID})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if len(relations) == 0 {
|
|
return []*dbmodels.Entry{}, nil
|
|
}
|
|
entryIDs := []any{}
|
|
for _, relation := range relations {
|
|
if strings.TrimSpace(relation.Type()) != preferredSeriesRelationType {
|
|
continue
|
|
}
|
|
entryIDs = append(entryIDs, relation.Entry())
|
|
}
|
|
if len(entryIDs) == 0 {
|
|
return []*dbmodels.Entry{}, nil
|
|
}
|
|
return dbmodels.Entries_IDs(app, entryIDs)
|
|
}
|
|
|
|
type reiheEditForm struct {
|
|
CSRFToken string `form:"csrf_token"`
|
|
LastEdited string `form:"last_edited"`
|
|
Title string `form:"title"`
|
|
Pseudonyms string `form:"pseudonyms"`
|
|
Annotation string `form:"annotation"`
|
|
References string `form:"references"`
|
|
Frequency string `form:"frequency"`
|
|
Status string `form:"status"`
|
|
Comment string `form:"edit_comment"`
|
|
}
|
|
|
|
func (p *ReiheEditPage) POST(engine *templating.Engine, app core.App) HandleFunc {
|
|
return func(e *core.RequestEvent) error {
|
|
id := e.Request.PathValue("id")
|
|
req := templating.NewRequest(e)
|
|
|
|
formdata := reiheEditForm{}
|
|
if err := e.BindBody(&formdata); err != nil {
|
|
return p.renderError(engine, app, e, "Formulardaten ungültig.")
|
|
}
|
|
|
|
if err := req.CheckCSRF(formdata.CSRFToken); err != nil {
|
|
return p.renderError(engine, app, e, err.Error())
|
|
}
|
|
|
|
series, err := dbmodels.Series_MusenalmID(app, id)
|
|
if err != nil {
|
|
return engine.Response404(e, err, nil)
|
|
}
|
|
|
|
if formdata.LastEdited != "" {
|
|
lastEdited, err := types.ParseDateTime(formdata.LastEdited)
|
|
if err != nil {
|
|
return p.renderError(engine, app, e, "Ungültiger Bearbeitungszeitstempel.")
|
|
}
|
|
if !series.Updated().Time().Equal(lastEdited.Time()) {
|
|
return p.renderError(engine, app, e, "Die Reihe wurde inzwischen geändert. Bitte Seite neu laden.")
|
|
}
|
|
}
|
|
|
|
title := strings.TrimSpace(formdata.Title)
|
|
if title == "" {
|
|
return p.renderError(engine, app, e, "Reihentitel ist erforderlich.")
|
|
}
|
|
|
|
status := strings.TrimSpace(formdata.Status)
|
|
if status == "" || !slices.Contains(dbmodels.EDITORSTATE_VALUES, status) {
|
|
return p.renderError(engine, app, e, "Ungültiger Status.")
|
|
}
|
|
|
|
user := req.User()
|
|
if err := app.RunInTransaction(func(tx core.App) error {
|
|
series.SetTitle(title)
|
|
series.SetPseudonyms(strings.TrimSpace(formdata.Pseudonyms))
|
|
series.SetAnnotation(strings.TrimSpace(formdata.Annotation))
|
|
series.SetReferences(strings.TrimSpace(formdata.References))
|
|
series.SetFrequency(strings.TrimSpace(formdata.Frequency))
|
|
series.SetEditState(status)
|
|
series.SetComment(strings.TrimSpace(formdata.Comment))
|
|
if user != nil {
|
|
series.SetEditor(user.Id)
|
|
}
|
|
return tx.Save(series)
|
|
}); err != nil {
|
|
app.Logger().Error("Failed to save series", "series_id", series.Id, "error", err)
|
|
return p.renderError(engine, app, e, "Speichern fehlgeschlagen.")
|
|
}
|
|
|
|
redirect := fmt.Sprintf("/reihe/%s/edit?saved_message=%s", id, url.QueryEscape("Änderungen gespeichert."))
|
|
return e.Redirect(http.StatusSeeOther, redirect)
|
|
}
|
|
}
|