Files
LektorenPlan/web/web/exchange_handlers.go
T
2026-11-12 20:00:33 +01:00

172 lines
5.3 KiB
Go

package web
import (
"encoding/base64"
"encoding/json"
"io"
"net/http"
"strconv"
"strings"
"time"
"lektorenplan/domain"
"lektorenplan/store"
)
type exchangePageData struct {
Range domain.DayRange
Start string
End string
Scope store.ExchangeScope
Resource store.ExchangeSummary
Preview *store.ExchangeSummary
PreviewToken string
FileName string
Replace bool
CanEdit bool
LastImport string
}
func (s *Server) handleExchange(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
if tenant == nil {
s.renderNoTenant(w, r)
return
}
rng := s.rangeFromRequest(r)
resources, err := s.store.ExportResources(r.Context(), tenant.ID)
if err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Austausch", err.Error())
return
}
scope := store.ExchangeScope(strings.TrimSpace(r.URL.Query().Get("scope")))
if scope != store.ScopePlan {
scope = store.ScopeResources
}
page := exchangePageData{
Range: rng, Start: domain.Key(rng.Start), End: domain.Key(rng.End),
Scope: scope, Resource: resources.Summary(),
CanEdit: s.store.CanEditTenant(r.Context(), user, tenant.ID),
}
data := s.baseView(w, r, "Austausch", "exchange")
data.Data = page
s.renderPage(w, r, "exchange", data)
}
func (s *Server) handleExport(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
if tenant == nil {
s.renderNoTenant(w, r)
return
}
scope := store.ExchangeScope(strings.TrimSpace(r.URL.Query().Get("scope")))
rng := s.rangeFromRequest(r)
var (
exchange store.PlanExchange
err error
)
if scope == store.ScopeResources {
exchange, err = s.store.ExportResources(r.Context(), tenant.ID)
} else {
scope = store.ScopePlan
exchange, err = s.store.ExportPlan(r.Context(), tenant.ID, rng)
}
if err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Export", err.Error())
return
}
body, err := json.Marshal(exchange)
if err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Export", err.Error())
return
}
name := "LektorenPlan-" + tenant.Slug + "-" + string(scope) + "-" + domain.Key(domain.Today()) + ".json"
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.Header().Set("Content-Disposition", `attachment; filename="`+name+`"`)
w.Header().Set("Content-Length", strconv.Itoa(len(body)))
_, _ = w.Write(body)
}
func (s *Server) handleImport(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
if tenant == nil {
s.renderNoTenant(w, r)
return
}
if strings.TrimSpace(r.FormValue("confirm")) == "1" {
encoded := strings.TrimSpace(r.FormValue("payload"))
payload, err := base64.RawURLEncoding.DecodeString(encoded)
if err != nil {
s.setFlash(w, "Die Importdaten konnten nicht gelesen werden.", "error")
s.redirect(w, r, "/exchange")
return
}
exchange, err := store.ParseExchange(payload)
if err != nil {
s.setFlash(w, err.Error(), "error")
s.redirect(w, r, "/exchange")
return
}
replace := r.FormValue("replace") == "1" || r.FormValue("replace") == "on"
summary, err := s.store.ApplyExchange(r.Context(), tenant.ID, exchange, replace)
if err != nil {
s.setFlash(w, "Der Import ist fehlgeschlagen: "+err.Error(), "error")
s.redirect(w, r, "/exchange")
return
}
_ = s.store.SetTenantSetting(r.Context(), tenant.ID, "lastExchangeImport", time.Now().UTC().Format(time.RFC3339))
s.setFlash(w, importMessage(summary), "success")
s.redirect(w, r, "/exchange")
return
}
file, header, err := r.FormFile("file")
if err != nil {
s.setFlash(w, "Bitte eine JSON-Datei auswählen.", "error")
s.redirect(w, r, "/exchange")
return
}
defer file.Close()
data, err := io.ReadAll(io.LimitReader(file, 32<<20))
if err != nil {
s.setFlash(w, "Die Datei konnte nicht gelesen werden.", "error")
s.redirect(w, r, "/exchange")
return
}
exchange, err := store.ParseExchange(data)
if err != nil {
s.setFlash(w, err.Error(), "error")
s.redirect(w, r, "/exchange")
return
}
summary := exchange.Summary()
rng := s.rangeFromRequest(r)
if exchange.Range.Start != "" && exchange.Range.End != "" {
if parsed, ok := domain.DateFromKey(exchange.Range.Start); ok {
rng.Start = parsed
}
if parsed, ok := domain.DateFromKey(exchange.Range.End); ok {
rng.End = parsed
}
}
page := exchangePageData{
Range: rng, Start: domain.Key(rng.Start), End: domain.Key(rng.End),
Scope: exchange.Scope, Resource: summary, Preview: &summary,
PreviewToken: base64.RawURLEncoding.EncodeToString(data),
FileName: header.Filename,
Replace: r.FormValue("replace") == "1" || r.FormValue("replace") == "on",
CanEdit: s.store.CanEditTenant(r.Context(), user, tenant.ID),
}
view := s.baseView(w, r, "Import prüfen", "exchange")
view.Data = page
s.renderPage(w, r, "exchange", view)
}
func importMessage(summary store.ExchangeSummary) string {
parts := []string{
plural(summary.Churches, "Kirche", "Kirchen"),
plural(summary.People, "Person", "Personen"),
plural(summary.Templates, "Vorlage", "Vorlagen"),
plural(summary.Services, "Gottesdienst", "Gottesdienste"),
plural(summary.Assignments, "Einteilung", "Einteilungen"),
}
return "Import abgeschlossen: " + strings.Join(parts, ", ") + "."
}