172 lines
5.3 KiB
Go
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, ", ") + "."
|
|
}
|