Gastansicht, Verbesserungen bei Planung

This commit is contained in:
concierge committed 2026-11-18 07:57:00 +01:00
1 parent b3afa3ef32
commit c08d43e7dd
38 files changed
+3845 -219

No files matched your search

+442
View File
@@ -0,0 +1,442 @@
package store
import (
"context"
"crypto/rand"
"crypto/sha256"
"crypto/subtle"
"database/sql"
"encoding/base64"
"encoding/hex"
"errors"
"strings"
"time"
"lektorenplan/domain"
)
// Swap request states.
const (
SwapPending = "pending"
SwapAccepted = "accepted"
SwapDeclined = "declined"
SwapCancelled = "cancelled"
)
// SwapRequest is one proposed exchange of two assignments.
type SwapRequest struct {
ID string
TenantID string
RequesterUserID string
RequesterPersonID string
TargetUserID string
TargetPersonID string
OfferedAssignmentID string
WantedAssignmentID string
Status string
TokenHash string
CreatedAt time.Time
RespondedAt time.Time
}
// SwapAssignmentInfo bundles an assignment with its service.
type SwapAssignmentInfo struct {
Assignment domain.Assignment
Service domain.ServiceOccurrence
}
func swapTokenHash(token string) string {
sum := sha256.Sum256([]byte(token))
return hex.EncodeToString(sum[:])
}
// SwapTokenMatches reports whether a plaintext e-mail token belongs to the
// stored request.
func SwapTokenMatches(request *SwapRequest, token string) bool {
if request == nil || request.TokenHash == "" || token == "" {
return false
}
return subtle.ConstantTimeCompare([]byte(request.TokenHash), []byte(swapTokenHash(token))) == 1
}
func newSwapToken() (string, error) {
raw := make([]byte, 32)
if _, err := rand.Read(raw); err != nil {
return "", err
}
return base64.RawURLEncoding.EncodeToString(raw), nil
}
func scanSwapRequest(row rowScanner) (*SwapRequest, error) {
var request SwapRequest
var created, responded string
if err := row.Scan(&request.ID, &request.TenantID, &request.RequesterUserID,
&request.RequesterPersonID, &request.TargetUserID, &request.TargetPersonID,
&request.OfferedAssignmentID, &request.WantedAssignmentID, &request.Status,
&request.TokenHash, &created, &responded); err != nil {
return nil, err
}
request.CreatedAt = parseTime(created)
request.RespondedAt = parseTime(responded)
return &request, nil
}
const swapRequestColumns = `id, tenant_id, requester_user_id, requester_person_id,
target_user_id, target_person_id, offered_assignment_id, wanted_assignment_id,
status, token_hash, created_at, responded_at`
// SwapRequestByToken loads a request by its unhashed e-mail token.
func (s *Store) SwapRequestByToken(ctx context.Context, tenantID, token string) (*SwapRequest, error) {
row := s.db.QueryRowContext(ctx, `SELECT `+swapRequestColumns+`
FROM swap_requests WHERE tenant_id=? AND token_hash=?`,
tenantID, swapTokenHash(strings.TrimSpace(token)))
request, err := scanSwapRequest(row)
if errors.Is(err, sql.ErrNoRows) {
return nil, ErrNotFound
}
return request, err
}
// SwapRequestByID loads one request of a tenant.
func (s *Store) SwapRequestByID(ctx context.Context, tenantID, id string) (*SwapRequest, error) {
row := s.db.QueryRowContext(ctx, `SELECT `+swapRequestColumns+`
FROM swap_requests WHERE tenant_id=? AND id=?`, tenantID, id)
request, err := scanSwapRequest(row)
if errors.Is(err, sql.ErrNoRows) {
return nil, ErrNotFound
}
return request, err
}
// swapAssignmentInfo loads one assignment together with its service.
func (s *Store) SwapAssignmentInfo(ctx context.Context, tenantID, assignmentID string) (*SwapAssignmentInfo, error) {
row := s.db.QueryRowContext(ctx, `
SELECT a.id, a.service_id, a.person_id, a.role, a.locked, a.note, a.created_at,
s.id, s.church_id, s.location, s.template_id, s.date, s.time_minutes,
s.title, s.lectors_needed, s.helpers_needed, s.kind, s.notes,
s.locked, s.created_at
FROM assignments a
JOIN services s ON s.tenant_id=a.tenant_id AND s.id=a.service_id
WHERE a.tenant_id=? AND a.id=?`, tenantID, assignmentID)
var info SwapAssignmentInfo
var role, aCreated, date, kind, sCreated, location string
var templateID sql.NullString
var aLocked, sLocked int
if err := row.Scan(&info.Assignment.ID, &info.Assignment.ServiceID,
&info.Assignment.PersonID, &role, &aLocked, &info.Assignment.Note, &aCreated,
&info.Service.ID, &info.Service.ChurchID, &location, &templateID, &date,
&info.Service.TimeMinutes, &info.Service.Title, &info.Service.LectorsNeeded,
&info.Service.HelpersNeeded, &kind, &info.Service.Notes, &sLocked, &sCreated); err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, ErrNotFound
}
return nil, err
}
info.Assignment.Role = domain.Role(role)
info.Assignment.Locked = aLocked != 0
info.Assignment.CreatedAt = parseTime(aCreated)
if location != "" {
info.Service.Location = &location
}
if templateID.Valid && templateID.String != "" {
value := templateID.String
info.Service.TemplateID = &value
}
info.Service.Date = domain.MustDate(date)
info.Service.Kind = domain.ServiceKind(kind)
info.Service.Locked = sLocked != 0
info.Service.CreatedAt = parseTime(sCreated)
return &info, nil
}
func (s *Store) personAbsentOn(ctx context.Context, tenantID, personID string, date time.Time) bool {
var count int
err := s.db.QueryRowContext(ctx, `
SELECT COUNT(*) FROM absences
WHERE tenant_id=? AND person_id=? AND start_date<=? AND end_date>=?`,
tenantID, personID, domain.Key(date), domain.Key(date)).Scan(&count)
return err == nil && count > 0
}
func (s *Store) assignmentConflict(ctx context.Context, tenantID, serviceID, personID string, role domain.Role, excludeID string) bool {
var count int
err := s.db.QueryRowContext(ctx, `
SELECT COUNT(*) FROM assignments
WHERE tenant_id=? AND service_id=? AND person_id=? AND role=? AND id<>?`,
tenantID, serviceID, personID, string(role), excludeID).Scan(&count)
return err == nil && count > 0
}
func (s *Store) pendingSwapForAssignment(ctx context.Context, tenantID, assignmentID, excludeRequestID string) bool {
var count int
err := s.db.QueryRowContext(ctx, `
SELECT COUNT(*) FROM swap_requests
WHERE tenant_id=? AND status=? AND id<>?
AND (offered_assignment_id=? OR wanted_assignment_id=?)`,
tenantID, SwapPending, excludeRequestID, assignmentID, assignmentID).Scan(&count)
return err == nil && count > 0
}
// swapConsentExists verifies the mutual address release that makes both the
// request and the response e-mail possible.
func (s *Store) swapConsentExists(ctx context.Context, tenantID, requesterUserID, requesterPersonID, targetUserID, targetPersonID string) bool {
return s.ContactShareExists(ctx, tenantID, targetPersonID, requesterUserID) &&
s.ContactShareExists(ctx, tenantID, requesterPersonID, targetUserID)
}
// validateSwapPair checks every planning and privacy precondition for a swap.
// excludeRequestID is the request currently being answered, if any.
func (s *Store) validateSwapPair(ctx context.Context, tenantID, requesterPersonID, targetPersonID, offeredID, wantedID, excludeRequestID string) (*SwapAssignmentInfo, *SwapAssignmentInfo, error) {
if requesterPersonID == "" || targetPersonID == "" || offeredID == "" || wantedID == "" {
return nil, nil, errors.New("Für den Tausch fehlen Angaben")
}
if requesterPersonID == targetPersonID {
return nil, nil, errors.New("Ein Tausch mit sich selbst ist nicht möglich")
}
offered, err := s.SwapAssignmentInfo(ctx, tenantID, offeredID)
if err != nil {
return nil, nil, errors.New("Der angebotene Einsatz wurde nicht gefunden")
}
wanted, err := s.SwapAssignmentInfo(ctx, tenantID, wantedID)
if err != nil {
return nil, nil, errors.New("Der gewünschte Einsatz wurde nicht gefunden")
}
if offered.Assignment.PersonID != requesterPersonID {
return nil, nil, errors.New("Der angebotene Einsatz gehört nicht mehr zu Ihnen")
}
if wanted.Assignment.PersonID != targetPersonID {
return nil, nil, errors.New("Der gewünschte Einsatz gehört nicht mehr zur angefragten Person")
}
if offered.Assignment.Role != wanted.Assignment.Role {
return nil, nil, errors.New("Es können nur Einsätze derselben Rolle getauscht werden")
}
today := domain.Today()
if offered.Service.Date.Before(today) || wanted.Service.Date.Before(today) {
return nil, nil, errors.New("Vergangene Einsätze können nicht getauscht werden")
}
if offered.Service.Locked || offered.Assignment.Locked || wanted.Service.Locked || wanted.Assignment.Locked {
return nil, nil, errors.New("Gesperrte Einsätze können nicht getauscht werden")
}
if s.personAbsentOn(ctx, tenantID, targetPersonID, offered.Service.Date) {
return nil, nil, errors.New("Die angefragte Person ist am angebotenen Termin als abwesend eingetragen")
}
if s.personAbsentOn(ctx, tenantID, requesterPersonID, wanted.Service.Date) {
return nil, nil, errors.New("Sie sind am gewünschten Termin als abwesend eingetragen")
}
if s.assignmentConflict(ctx, tenantID, wanted.Service.ID, requesterPersonID, wanted.Assignment.Role, wanted.Assignment.ID) {
return nil, nil, errors.New("Sie sind für diesen Gottesdienst bereits in derselben Rolle eingeteilt")
}
if s.assignmentConflict(ctx, tenantID, offered.Service.ID, targetPersonID, offered.Assignment.Role, offered.Assignment.ID) {
return nil, nil, errors.New("Die angefragte Person ist für diesen Gottesdienst bereits in derselben Rolle eingeteilt")
}
if s.pendingSwapForAssignment(ctx, tenantID, offered.Assignment.ID, excludeRequestID) ||
s.pendingSwapForAssignment(ctx, tenantID, wanted.Assignment.ID, excludeRequestID) {
return nil, nil, errors.New("Für einen der beiden Einsätze liegt bereits eine offene Tauschanfrage vor")
}
return offered, wanted, nil
}
// SwapOptions lists the requester's future assignments that can be offered for
// the wanted assignment of the target person.
func (s *Store) SwapOptions(ctx context.Context, tenantID, requesterPersonID, targetPersonID, wantedAssignmentID string) ([]SwapAssignmentInfo, error) {
wanted, err := s.SwapAssignmentInfo(ctx, tenantID, wantedAssignmentID)
if err != nil {
return nil, errors.New("Der gewünschte Einsatz wurde nicht gefunden")
}
if wanted.Assignment.PersonID != targetPersonID {
return nil, errors.New("Der gewünschte Einsatz gehört nicht mehr zur angefragten Person")
}
if wanted.Service.Date.Before(domain.Today()) {
return nil, errors.New("Vergangene Einsätze können nicht getauscht werden")
}
if wanted.Service.Locked || wanted.Assignment.Locked {
return nil, errors.New("Gesperrte Einsätze können nicht getauscht werden")
}
assignments, err := s.AssignmentsForPerson(ctx, tenantID, requesterPersonID)
if err != nil {
return nil, err
}
out := make([]SwapAssignmentInfo, 0, len(assignments))
for _, assignment := range assignments {
if assignment.Role != wanted.Assignment.Role || assignment.ID == wanted.Assignment.ID {
continue
}
service, err := s.Service(ctx, tenantID, assignment.ServiceID)
if err != nil || service.Date.Before(domain.Today()) {
continue
}
offered, _, err := s.validateSwapPair(ctx, tenantID, requesterPersonID,
targetPersonID, assignment.ID, wantedAssignmentID, "")
if err != nil {
continue
}
out = append(out, *offered)
}
return out, nil
}
// CreateSwapRequest validates a proposed exchange, stores it and returns the
// plaintext e-mail token. Only the token hash is persisted.
func (s *Store) CreateSwapRequest(ctx context.Context, tenantID, requesterUserID, requesterPersonID, targetUserID, targetPersonID, offeredID, wantedID string) (*SwapRequest, string, error) {
if !s.swapConsentExists(ctx, tenantID, requesterUserID, requesterPersonID, targetUserID, targetPersonID) {
return nil, "", errors.New("Für eine Tauschanfrage müssen beide Seiten ihre E-Mail-Adresse gegenseitig freigegeben haben")
}
if _, _, err := s.validateSwapPair(ctx, tenantID, requesterPersonID, targetPersonID, offeredID, wantedID, ""); err != nil {
return nil, "", err
}
token, err := newSwapToken()
if err != nil {
return nil, "", err
}
now := time.Now().UTC()
request := &SwapRequest{
ID: domain.NewID(), TenantID: tenantID,
RequesterUserID: requesterUserID, RequesterPersonID: requesterPersonID,
TargetUserID: targetUserID, TargetPersonID: targetPersonID,
OfferedAssignmentID: offeredID, WantedAssignmentID: wantedID,
Status: SwapPending, TokenHash: swapTokenHash(token), CreatedAt: now,
}
_, err = s.db.ExecContext(ctx, `
INSERT INTO swap_requests(id, tenant_id, requester_user_id, requester_person_id,
target_user_id, target_person_id, offered_assignment_id, wanted_assignment_id,
status, token_hash, created_at, responded_at)
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, '')`,
request.ID, request.TenantID, request.RequesterUserID, request.RequesterPersonID,
request.TargetUserID, request.TargetPersonID, request.OfferedAssignmentID,
request.WantedAssignmentID, request.Status, request.TokenHash,
request.CreatedAt.Format(time.RFC3339))
if err != nil {
return nil, "", err
}
return request, token, nil
}
// RespondSwapRequest accepts or declines a request on behalf of the target
// account. Accepting swaps both assignments atomically and revalidates every
// planning rule first.
func (s *Store) RespondSwapRequest(ctx context.Context, tenantID, token, targetUserID string, accept bool) (*SwapRequest, error) {
request, err := s.SwapRequestByToken(ctx, tenantID, token)
if err != nil {
return nil, err
}
if request.TargetUserID != targetUserID {
return nil, errors.New("Diese Tauschanfrage richtet sich an ein anderes Konto")
}
if request.Status != SwapPending {
return nil, errors.New("Diese Tauschanfrage wurde bereits beantwortet")
}
now := time.Now().UTC()
if !accept {
result, err := s.db.ExecContext(ctx, `
UPDATE swap_requests SET status=?, responded_at=?
WHERE tenant_id=? AND id=? AND status=?`,
SwapDeclined, now.Format(time.RFC3339), tenantID, request.ID, SwapPending)
if err != nil {
return nil, err
}
if affected, _ := result.RowsAffected(); affected == 0 {
return nil, errors.New("Diese Tauschanfrage wurde bereits beantwortet")
}
request.Status = SwapDeclined
request.RespondedAt = now
return request, nil
}
offered, wanted, err := s.validateSwapPair(ctx, tenantID, request.RequesterPersonID,
request.TargetPersonID, request.OfferedAssignmentID, request.WantedAssignmentID, request.ID)
if err != nil {
return nil, err
}
if !s.swapConsentExists(ctx, tenantID, request.RequesterUserID, request.RequesterPersonID,
request.TargetUserID, request.TargetPersonID) {
return nil, errors.New("Die gegenseitige E-Mail-Freigabe wurde inzwischen entzogen; der Tausch kann nicht angenommen werden")
}
tempPerson := "swap-tmp-" + request.ID
err = s.transaction(ctx, func(tx *sql.Tx) error {
update := func(personID, assignmentID, expected string) error {
result, err := tx.ExecContext(ctx, `
UPDATE assignments SET person_id=?
WHERE tenant_id=? AND id=? AND person_id=?`,
personID, tenantID, assignmentID, expected)
if err != nil {
return err
}
if affected, _ := result.RowsAffected(); affected != 1 {
return errors.New("Die Einteilung hat sich inzwischen geändert")
}
return nil
}
if err := update(tempPerson, offered.Assignment.ID, request.RequesterPersonID); err != nil {
return err
}
if err := update(request.RequesterPersonID, wanted.Assignment.ID, request.TargetPersonID); err != nil {
return err
}
if err := update(request.TargetPersonID, offered.Assignment.ID, tempPerson); err != nil {
return err
}
result, err := tx.ExecContext(ctx, `
UPDATE swap_requests SET status=?, responded_at=?
WHERE tenant_id=? AND id=? AND status=?`,
SwapAccepted, now.Format(time.RFC3339), tenantID, request.ID, SwapPending)
if err != nil {
return err
}
if affected, _ := result.RowsAffected(); affected != 1 {
return errors.New("Diese Tauschanfrage wurde bereits beantwortet")
}
// Competing requests for the same assignments can no longer be
// fulfilled after this swap.
_, err = tx.ExecContext(ctx, `
UPDATE swap_requests SET status=?, responded_at=?
WHERE tenant_id=? AND status=? AND id<>?
AND (offered_assignment_id IN (?, ?) OR wanted_assignment_id IN (?, ?))`,
SwapCancelled, now.Format(time.RFC3339), tenantID, SwapPending, request.ID,
offered.Assignment.ID, wanted.Assignment.ID,
offered.Assignment.ID, wanted.Assignment.ID)
return err
})
if err != nil {
return nil, err
}
request.Status = SwapAccepted
request.RespondedAt = now
return request, nil
}
// PendingSwapAssignmentIDs maps assignment IDs of open swap requests to the
// request ID so the plan and service views can mark them.
func (s *Store) PendingSwapAssignmentIDs(ctx context.Context, tenantID string) (map[string]string, error) {
rows, err := s.db.QueryContext(ctx, `
SELECT id, offered_assignment_id, wanted_assignment_id
FROM swap_requests WHERE tenant_id=? AND status=?`,
tenantID, SwapPending)
if err != nil {
return nil, err
}
defer rows.Close()
out := map[string]string{}
for rows.Next() {
var id, offered, wanted string
if err := rows.Scan(&id, &offered, &wanted); err != nil {
return nil, err
}
out[offered] = id
out[wanted] = id
}
return out, rows.Err()
}
// SwapStatusLabel returns the German label of a request state.
func SwapStatusLabel(status string) string {
switch status {
case SwapAccepted:
return "angenommen"
case SwapDeclined:
return "abgelehnt"
case SwapCancelled:
return "abgebrochen"
default:
return "offen"
}
}