388 lines
15 KiB
Go
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")
|
|
}
|