Files
LektorenPlan/web/web/swap_handlers.go
T

388 lines
15 KiB
Go

package web
import (
"context"
"fmt"
"net/http"
"net/url"
"strings"
"lektorenplan/domain"
"lektorenplan/store"
)
type swapAssignmentView struct {
Assignment domain.Assignment
Service domain.ServiceOccurrence
Church domain.Church
}
func (v swapAssignmentView) Exists() bool { return v.Assignment.ID != "" }
type swapRequestPageData struct {
Request *store.SwapRequest
Token string
RequesterPerson domain.Person
TargetPerson domain.Person
Offered swapAssignmentView
Wanted swapAssignmentView
StatusLabel string
CanRespond bool
Action string
ShowRequestMail bool
RequestMailto string
ResponseMailto string
ResponseUnavailable bool
}
type swapNewPageData struct {
Requester domain.Person
Target domain.Person
Wanted swapAssignmentView
Options []swapAssignmentView
}
func (s *Server) swapReader(user *store.User, tenant *store.Tenant) (string, bool) {
if tenant == nil || user == nil || user.Role != store.RoleReader {
return "", false
}
return user.LinkedPerson(tenant.ID)
}
func (s *Server) swapView(ctx context.Context, tenantID string, info store.SwapAssignmentInfo) swapAssignmentView {
view := swapAssignmentView{Assignment: info.Assignment, Service: info.Service}
if church, err := s.store.Church(ctx, tenantID, info.Service.ChurchID); err == nil {
view.Church = *church
} else {
view.Church = domain.Church{ID: info.Service.ChurchID, Name: "Unbekannte Kirche"}
}
return view
}
func (s *Server) swapConsent(ctx context.Context, tenantID, requesterUserID, requesterPersonID, targetUserID, targetPersonID string) bool {
return s.store.ContactShareExists(ctx, tenantID, targetPersonID, requesterUserID) &&
s.store.ContactShareExists(ctx, tenantID, requesterPersonID, targetUserID)
}
func (s *Server) swapRequestTarget(ctx context.Context, tenantID, personID string) (string, bool) {
return s.store.ReaderForPerson(ctx, tenantID, personID)
}
func (s *Server) handleSwapNew(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
if tenant == nil {
s.renderNoTenant(w, r)
return
}
requesterPersonID, ok := s.swapReader(user, tenant)
if !ok {
s.renderError(w, r, http.StatusForbidden, "Tausch",
"Nur verknüpfte Leser-Konten können Einsätze tauschen.")
return
}
wantedID := strings.TrimSpace(r.URL.Query().Get("assignment"))
// Load the wanted assignment first to determine the target person, then
// compute the selectable own assignments.
wantedInfo, err := s.store.SwapAssignmentInfo(r.Context(), tenant.ID, wantedID)
if err != nil {
s.renderError(w, r, http.StatusNotFound, "Tausch", "Dieser Einsatz wurde nicht gefunden.")
return
}
targetUserID, ok := s.swapRequestTarget(r.Context(), tenant.ID, wantedInfo.Assignment.PersonID)
if !ok {
s.renderError(w, r, http.StatusConflict, "Tausch",
"Für die angefragte Person ist kein Leser-Konto verknüpft.")
return
}
if !s.swapConsent(r.Context(), tenant.ID, user.ID, requesterPersonID, targetUserID, wantedInfo.Assignment.PersonID) {
s.renderError(w, r, http.StatusForbidden, "Tausch",
"Für eine Tauschanfrage müssen beide Seiten ihre E-Mail-Adresse gegenseitig freigegeben haben. "+
"Prüfen Sie die Einstellungen unter „Team & Abwesenheiten“.")
return
}
options, err := s.store.SwapOptions(r.Context(), tenant.ID, requesterPersonID,
wantedInfo.Assignment.PersonID, wantedID)
if err != nil {
s.renderError(w, r, http.StatusConflict, "Tausch", err.Error())
return
}
requester, err := s.store.Person(r.Context(), tenant.ID, requesterPersonID)
if err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Tausch", err.Error())
return
}
target, err := s.store.Person(r.Context(), tenant.ID, wantedInfo.Assignment.PersonID)
if err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Tausch", err.Error())
return
}
page := swapNewPageData{
Requester: *requester,
Target: *target,
Wanted: s.swapView(r.Context(), tenant.ID, *wantedInfo),
}
for _, option := range options {
page.Options = append(page.Options, s.swapView(r.Context(), tenant.ID, option))
}
data := s.baseView(w, r, "Tausch anfragen", "team")
data.Data = page
s.renderPage(w, r, "swap_request", data)
}
func (s *Server) handleSwapRequestCreate(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
if tenant == nil {
s.renderNoTenant(w, r)
return
}
requesterPersonID, ok := s.swapReader(user, tenant)
if !ok {
s.renderError(w, r, http.StatusForbidden, "Tausch",
"Nur verknüpfte Leser-Konten können Einsätze tauschen.")
return
}
wantedID := strings.TrimSpace(r.FormValue("wanted"))
offeredID := strings.TrimSpace(r.FormValue("offered"))
wantedInfo, err := s.store.SwapAssignmentInfo(r.Context(), tenant.ID, wantedID)
if err != nil {
s.renderError(w, r, http.StatusNotFound, "Tausch", "Der gewünschte Einsatz wurde nicht gefunden.")
return
}
if wantedInfo.Assignment.PersonID == requesterPersonID {
s.renderError(w, r, http.StatusBadRequest, "Tausch", "Ein Tausch mit sich selbst ist nicht möglich.")
return
}
targetUserID, ok := s.swapRequestTarget(r.Context(), tenant.ID, wantedInfo.Assignment.PersonID)
if !ok {
s.renderError(w, r, http.StatusConflict, "Tausch",
"Für die angefragte Person ist kein Leser-Konto verknüpft.")
return
}
if !s.swapConsent(r.Context(), tenant.ID, user.ID, requesterPersonID, targetUserID, wantedInfo.Assignment.PersonID) {
s.renderError(w, r, http.StatusForbidden, "Tausch",
"Für eine Tauschanfrage müssen beide Seiten ihre E-Mail-Adresse gegenseitig freigegeben haben.")
return
}
request, token, err := s.store.CreateSwapRequest(r.Context(), tenant.ID, user.ID,
requesterPersonID, targetUserID, wantedInfo.Assignment.PersonID, offeredID, wantedID)
if err != nil {
s.renderError(w, r, http.StatusConflict, "Tausch", err.Error())
return
}
s.redirect(w, r, "/swap/requests/"+request.ID+"?token="+url.QueryEscape(token))
}
func (s *Server) handleSwapRequestView(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
if tenant == nil {
s.renderNoTenant(w, r)
return
}
request, err := s.store.SwapRequestByID(r.Context(), tenant.ID, r.PathValue("id"))
if err != nil {
s.renderError(w, r, http.StatusNotFound, "Tausch", "Diese Tauschanfrage wurde nicht gefunden.")
return
}
if request.RequesterUserID != user.ID && request.TargetUserID != user.ID {
s.renderError(w, r, http.StatusForbidden, "Tausch", "Diese Tauschanfrage gehört nicht zu Ihrem Konto.")
return
}
token := strings.TrimSpace(r.URL.Query().Get("token"))
if token != "" && store.SwapTokenMatches(request, token) {
s.renderSwapPage(w, r, user, tenant, request, token, "")
return
}
s.renderSwapPage(w, r, user, tenant, request, "", "")
}
func (s *Server) handleSwapTokenView(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
if tenant == nil {
s.renderNoTenant(w, r)
return
}
token := strings.TrimSpace(r.PathValue("token"))
request, err := s.store.SwapRequestByToken(r.Context(), tenant.ID, token)
if err != nil {
s.renderError(w, r, http.StatusNotFound, "Tausch", "Diese Tauschanfrage wurde nicht gefunden oder ist abgelaufen.")
return
}
if request.RequesterUserID != user.ID && request.TargetUserID != user.ID {
s.renderError(w, r, http.StatusForbidden, "Tausch", "Diese Tauschanfrage gehört nicht zu Ihrem Konto.")
return
}
s.renderSwapPage(w, r, user, tenant, request, token, "")
}
func (s *Server) handleSwapTokenAction(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
if tenant == nil {
s.renderNoTenant(w, r)
return
}
action := strings.TrimSpace(r.PathValue("action"))
if action != "accept" && action != "decline" {
s.renderError(w, r, http.StatusNotFound, "Tausch", "Unbekannte Aktion.")
return
}
token := strings.TrimSpace(r.PathValue("token"))
request, err := s.store.SwapRequestByToken(r.Context(), tenant.ID, token)
if err != nil {
s.renderError(w, r, http.StatusNotFound, "Tausch", "Diese Tauschanfrage wurde nicht gefunden oder ist abgelaufen.")
return
}
if request.TargetUserID != user.ID {
s.renderError(w, r, http.StatusForbidden, "Tausch", "Diese Tauschanfrage richtet sich an ein anderes Konto.")
return
}
if request.Status != store.SwapPending {
s.setFlash(w, "Diese Tauschanfrage ist bereits "+store.SwapStatusLabel(request.Status)+".", "info")
s.redirect(w, r, "/swap/"+token)
return
}
s.renderSwapPage(w, r, user, tenant, request, token, action)
}
func (s *Server) handleSwapRespond(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
if tenant == nil {
s.renderNoTenant(w, r)
return
}
token := strings.TrimSpace(r.PathValue("token"))
action := strings.TrimSpace(r.FormValue("action"))
if action != "accept" && action != "decline" {
s.renderError(w, r, http.StatusBadRequest, "Tausch", "Unbekannte Aktion.")
return
}
request, err := s.store.SwapRequestByToken(r.Context(), tenant.ID, token)
if err != nil {
s.renderError(w, r, http.StatusNotFound, "Tausch", "Diese Tauschanfrage wurde nicht gefunden oder ist abgelaufen.")
return
}
if request.TargetUserID != user.ID {
s.renderError(w, r, http.StatusForbidden, "Tausch", "Diese Tauschanfrage richtet sich an ein anderes Konto.")
return
}
if _, err := s.store.RespondSwapRequest(r.Context(), tenant.ID, token, user.ID, action == "accept"); err != nil {
s.setFlash(w, "Die Tauschanfrage konnte nicht beantwortet werden: "+err.Error(), "error")
s.redirect(w, r, "/swap/"+token)
return
}
if action == "accept" {
s.setFlash(w, "Der Tausch wurde durchgeführt. Der Plan ist aktualisiert.", "success")
} else {
s.setFlash(w, "Die Tauschanfrage wurde abgelehnt. Der Plan bleibt unverändert.", "success")
}
s.redirect(w, r, "/swap/"+token)
}
func (s *Server) renderSwapPage(w http.ResponseWriter, r *http.Request, user *store.User, tenant *store.Tenant, request *store.SwapRequest, token, action string) {
requester, requesterErr := s.store.Person(r.Context(), tenant.ID, request.RequesterPersonID)
target, targetErr := s.store.Person(r.Context(), tenant.ID, request.TargetPersonID)
if requesterErr != nil || targetErr != nil {
s.renderError(w, r, http.StatusNotFound, "Tausch", "Die an der Tauschanfrage beteiligten Personen wurden nicht gefunden.")
return
}
page := swapRequestPageData{
Request: request,
Token: token,
RequesterPerson: *requester,
TargetPerson: *target,
StatusLabel: store.SwapStatusLabel(request.Status),
Action: action,
}
if offered, err := s.store.SwapAssignmentInfo(r.Context(), tenant.ID, request.OfferedAssignmentID); err == nil {
page.Offered = s.swapView(r.Context(), tenant.ID, *offered)
}
if wanted, err := s.store.SwapAssignmentInfo(r.Context(), tenant.ID, request.WantedAssignmentID); err == nil {
page.Wanted = s.swapView(r.Context(), tenant.ID, *wanted)
}
isRequester := request.RequesterUserID == user.ID
isTarget := request.TargetUserID == user.ID
page.CanRespond = isTarget && request.Status == store.SwapPending && token != ""
if isRequester && request.Status == store.SwapPending && token != "" && target.Email != "" {
page.ShowRequestMail = true
acceptURL := s.absoluteURL(r, "/swap/"+token+"/accept")
declineURL := s.absoluteURL(r, "/swap/"+token+"/decline")
subject := "Tauschanfrage: " + swapAssignmentSummary(page.Offered)
body := swapRequestEmailBody(*requester, *target, page.Offered, page.Wanted, acceptURL, declineURL)
page.RequestMailto = dispatchMailto(target.Email, subject, body)
}
if isTarget && (request.Status == store.SwapAccepted || request.Status == store.SwapDeclined) {
if requester.Email != "" {
subject := "Antwort auf die Tauschanfrage: " + swapAssignmentSummary(page.Wanted)
body := swapResponseEmailBody(*target, *requester, page.Offered, page.Wanted, request.Status)
page.ResponseMailto = dispatchMailto(requester.Email, subject, body)
} else {
page.ResponseUnavailable = true
}
}
data := s.baseView(w, r, "Tausch", "team")
data.Data = page
s.renderPage(w, r, "swap_detail", data)
}
func (s *Server) absoluteURL(r *http.Request, path string) string {
scheme := "http"
if r.TLS != nil {
scheme = "https"
}
if proto := strings.TrimSpace(strings.Split(r.Header.Get("X-Forwarded-Proto"), ",")[0]); proto != "" {
scheme = proto
}
host := r.Host
if forwarded := strings.TrimSpace(strings.Split(r.Header.Get("X-Forwarded-Host"), ",")[0]); forwarded != "" {
host = forwarded
}
return scheme + "://" + host + path
}
func swapAssignmentSummary(view swapAssignmentView) string {
if !view.Exists() {
return "Einsatz"
}
date := domain.LongString(view.Service.Date)
if view.Service.Title != "" {
return date + " · " + view.Service.Title
}
return date
}
func swapAssignmentLine(view swapAssignmentView) string {
if !view.Exists() {
return "Der Einsatz ist nicht mehr vorhanden."
}
church := view.Church.Name
if church == "" {
church = "Kirche unbekannt"
}
return fmt.Sprintf("%s, %s Uhr · %s\n %s (%s)",
domain.LongString(view.Service.Date), domain.TimeString(view.Service.TimeMinutes),
church, view.Service.Title, view.Assignment.Role.Title())
}
func swapRequestEmailBody(requester, target domain.Person, offered, wanted swapAssignmentView, acceptURL, declineURL string) string {
return strings.Join([]string{
"Guten Tag " + target.FullName() + ",",
requester.FullName() + " möchte mit Ihnen einen Dienst tauschen.",
"Ihr Einsatz, den " + requester.FullName() + " übernehmen würde:\n" + swapAssignmentLine(wanted),
"Der angebotene Einsatz von " + requester.FullName() + ":\n" + swapAssignmentLine(offered),
"Bitte antworten Sie nach der Anmeldung über einen dieser Links:\n\n" +
"Annehmen: " + acceptURL + "\n" +
"Ablehnen: " + declineURL,
"Der Plan wird erst geändert, nachdem Sie den Tausch auf der Bestätigungsseite angenommen haben.",
"Mit freundlichen Grüßen\nIhr Planungsteam",
}, "\n\n")
}
func swapResponseEmailBody(target, requester domain.Person, offered, wanted swapAssignmentView, status string) string {
answer := "angenommen"
if status == store.SwapDeclined {
answer = "abgelehnt"
}
return strings.Join([]string{
"Guten Tag " + requester.FullName() + ",",
target.FullName() + " hat Ihre Tauschanfrage " + answer + ".",
"Ihr angebotener Einsatz:\n" + swapAssignmentLine(offered),
"Der gewünschte Einsatz:\n" + swapAssignmentLine(wanted),
"Bei Annahme ist der Plan bereits aktualisiert. Bei Ablehnung bleibt der Plan unverändert.",
"Mit freundlichen Grüßen\nIhr Planungsteam",
}, "\n\n")
}