252 lines
8.0 KiB
Go
252 lines
8.0 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
|
|
"lektorenplan/domain"
|
|
)
|
|
|
|
// ExchangeScope selects what an exchange file contains.
|
|
type ExchangeScope string
|
|
|
|
const (
|
|
ScopeResources ExchangeScope = "resources"
|
|
ScopePlan ExchangeScope = "plan"
|
|
)
|
|
|
|
func (s ExchangeScope) Title() string {
|
|
if s == ScopeResources {
|
|
return "Ressourcen"
|
|
}
|
|
return "Planungsabschnitt"
|
|
}
|
|
|
|
// ExchangeRange is a serialisable inclusive day range.
|
|
type ExchangeRange struct {
|
|
Start string `json:"start"`
|
|
End string `json:"end"`
|
|
}
|
|
|
|
// ResourceBundle carries configuration and volunteer data.
|
|
type ResourceBundle struct {
|
|
Churches []domain.Church `json:"churches"`
|
|
People []domain.Person `json:"people"`
|
|
Absences []domain.Absence `json:"absences"`
|
|
Templates []domain.ServiceTemplate `json:"templates"`
|
|
Exceptions []domain.ServiceException `json:"exceptions"`
|
|
}
|
|
|
|
// PlanExchange is the JSON document exchanged with other installations.
|
|
type PlanExchange struct {
|
|
FormatVersion int `json:"formatVersion"`
|
|
ExportedAt time.Time `json:"exportedAt"`
|
|
AppName string `json:"appName"`
|
|
Scope ExchangeScope `json:"scope"`
|
|
Range ExchangeRange `json:"range"`
|
|
Resources ResourceBundle `json:"resources"`
|
|
Services []domain.ServiceOccurrence `json:"services"`
|
|
Assignments []domain.Assignment `json:"assignments"`
|
|
LiturgicalDays []domain.LiturgicalDay `json:"liturgicalDays"`
|
|
Note string `json:"note"`
|
|
}
|
|
|
|
// ExchangeSummary reports the imported record counts.
|
|
type ExchangeSummary struct {
|
|
Scope ExchangeScope `json:"scope"`
|
|
Range ExchangeRange `json:"range"`
|
|
Churches int `json:"churches"`
|
|
People int `json:"people"`
|
|
Templates int `json:"templates"`
|
|
Services int `json:"services"`
|
|
Assignments int `json:"assignments"`
|
|
LiturgicalDays int `json:"liturgicalDays"`
|
|
}
|
|
|
|
// Summary returns counts for display after import or before export.
|
|
func (e PlanExchange) Summary() ExchangeSummary {
|
|
return ExchangeSummary{
|
|
Scope: e.Scope, Range: e.Range,
|
|
Churches: len(e.Resources.Churches), People: len(e.Resources.People),
|
|
Templates: len(e.Resources.Templates), Services: len(e.Services),
|
|
Assignments: len(e.Assignments), LiturgicalDays: len(e.LiturgicalDays),
|
|
}
|
|
}
|
|
|
|
// MarshalJSON indents the exchange document for readability.
|
|
func (e PlanExchange) MarshalJSON() ([]byte, error) {
|
|
type alias PlanExchange
|
|
return json.MarshalIndent(alias(e), "", " ")
|
|
}
|
|
|
|
// ExportResources builds a resources-only exchange document.
|
|
func (s *Store) ExportResources(ctx context.Context, tenantID string) (PlanExchange, error) {
|
|
churches, err := s.Churches(ctx, tenantID)
|
|
if err != nil {
|
|
return PlanExchange{}, err
|
|
}
|
|
people, err := s.People(ctx, tenantID)
|
|
if err != nil {
|
|
return PlanExchange{}, err
|
|
}
|
|
// Contact details are only stored encrypted and tied to accounts. They are
|
|
// deliberately left out of exchange files.
|
|
for index := range people {
|
|
people[index].Email = ""
|
|
people[index].EmailLocked = false
|
|
}
|
|
absences, err := s.Absences(ctx, tenantID)
|
|
if err != nil {
|
|
return PlanExchange{}, err
|
|
}
|
|
templates, err := s.Templates(ctx, tenantID)
|
|
if err != nil {
|
|
return PlanExchange{}, err
|
|
}
|
|
exceptions, err := s.Exceptions(ctx, tenantID)
|
|
if err != nil {
|
|
return PlanExchange{}, err
|
|
}
|
|
return PlanExchange{
|
|
FormatVersion: 1, ExportedAt: time.Now().UTC(), AppName: "LektorenPlan Web",
|
|
Scope: ScopeResources,
|
|
Resources: ResourceBundle{
|
|
Churches: churches, People: people, Absences: absences,
|
|
Templates: templates, Exceptions: exceptions,
|
|
},
|
|
Note: "Export aus LektorenPlan Web",
|
|
}, nil
|
|
}
|
|
|
|
// ExportPlan builds a plan exchange document for a range.
|
|
func (s *Store) ExportPlan(ctx context.Context, tenantID string, r domain.DayRange) (PlanExchange, error) {
|
|
resources, err := s.ExportResources(ctx, tenantID)
|
|
if err != nil {
|
|
return PlanExchange{}, err
|
|
}
|
|
services, err := s.Services(ctx, tenantID, r)
|
|
if err != nil {
|
|
return PlanExchange{}, err
|
|
}
|
|
serviceIDs := make([]string, len(services))
|
|
for i, service := range services {
|
|
serviceIDs[i] = service.ID
|
|
}
|
|
assignments, err := s.AssignmentsForServices(ctx, tenantID, serviceIDs)
|
|
if err != nil {
|
|
return PlanExchange{}, err
|
|
}
|
|
liturgicalDays, err := s.LiturgicalDays(ctx, r)
|
|
if err != nil {
|
|
return PlanExchange{}, err
|
|
}
|
|
personIDs := map[string]bool{}
|
|
for _, assignment := range assignments {
|
|
personIDs[assignment.PersonID] = true
|
|
}
|
|
var relevantPeople []domain.Person
|
|
for _, person := range resources.Resources.People {
|
|
if personIDs[person.ID] {
|
|
relevantPeople = append(relevantPeople, person)
|
|
}
|
|
}
|
|
var relevantAbsences []domain.Absence
|
|
for _, absence := range resources.Resources.Absences {
|
|
if personIDs[absence.PersonID] {
|
|
relevantAbsences = append(relevantAbsences, absence)
|
|
}
|
|
}
|
|
resources.Resources.People = relevantPeople
|
|
resources.Resources.Absences = relevantAbsences
|
|
return PlanExchange{
|
|
FormatVersion: 1, ExportedAt: time.Now().UTC(), AppName: "LektorenPlan Web",
|
|
Scope: ScopePlan,
|
|
Range: ExchangeRange{Start: domain.Key(r.Start), End: domain.Key(r.End)},
|
|
Resources: resources.Resources, Services: services, Assignments: assignments,
|
|
LiturgicalDays: liturgicalDays,
|
|
Note: fmt.Sprintf("Export aus LektorenPlan Web · %s bis %s",
|
|
domain.Key(r.Start), domain.Key(r.End)),
|
|
}, nil
|
|
}
|
|
|
|
// ParseExchange decodes an uploaded JSON document.
|
|
func ParseExchange(data []byte) (PlanExchange, error) {
|
|
var exchange PlanExchange
|
|
if err := json.Unmarshal(data, &exchange); err != nil {
|
|
return exchange, fmt.Errorf("Die Datei konnte nicht gelesen werden: %w", err)
|
|
}
|
|
if exchange.FormatVersion < 1 {
|
|
exchange.FormatVersion = 1
|
|
}
|
|
if exchange.Scope == "" {
|
|
exchange.Scope = ScopePlan
|
|
}
|
|
if exchange.Scope != ScopeResources && exchange.Scope != ScopePlan {
|
|
return exchange, errors.New("Unbekannter Dateityp")
|
|
}
|
|
return exchange, nil
|
|
}
|
|
|
|
// ApplyExchange imports resources, services and assignments into a tenant.
|
|
func (s *Store) ApplyExchange(ctx context.Context, tenantID string, exchange PlanExchange, replaceExisting bool) (ExchangeSummary, error) {
|
|
if replaceExisting {
|
|
if err := s.DeleteAllTenantData(ctx, tenantID); err != nil {
|
|
return ExchangeSummary{}, err
|
|
}
|
|
}
|
|
// Use the store methods so validation and secondary cleanup stay in one place.
|
|
for _, church := range exchange.Resources.Churches {
|
|
if err := s.UpsertChurch(ctx, tenantID, church); err != nil {
|
|
return ExchangeSummary{}, err
|
|
}
|
|
}
|
|
for _, person := range exchange.Resources.People {
|
|
// Exchange files never carry contact details. Keep any encrypted
|
|
// values that already exist instead of deleting them on import.
|
|
if strings.TrimSpace(person.Email) == "" {
|
|
person.EmailLocked = true
|
|
}
|
|
if err := s.UpsertPerson(ctx, tenantID, person); err != nil {
|
|
return ExchangeSummary{}, err
|
|
}
|
|
}
|
|
for _, absence := range exchange.Resources.Absences {
|
|
if err := s.UpsertAbsence(ctx, tenantID, absence); err != nil {
|
|
return ExchangeSummary{}, err
|
|
}
|
|
}
|
|
for _, template := range exchange.Resources.Templates {
|
|
if err := s.UpsertTemplate(ctx, tenantID, template); err != nil {
|
|
return ExchangeSummary{}, err
|
|
}
|
|
}
|
|
for _, exception := range exchange.Resources.Exceptions {
|
|
if err := s.UpsertException(ctx, tenantID, exception); err != nil {
|
|
return ExchangeSummary{}, err
|
|
}
|
|
}
|
|
if len(exchange.LiturgicalDays) > 0 {
|
|
if err := s.UpsertLiturgicalDays(ctx, exchange.LiturgicalDays); err != nil {
|
|
return ExchangeSummary{}, err
|
|
}
|
|
}
|
|
for _, service := range exchange.Services {
|
|
if _, err := s.UpsertService(ctx, tenantID, service); err != nil {
|
|
return ExchangeSummary{}, err
|
|
}
|
|
}
|
|
for _, assignment := range exchange.Assignments {
|
|
if err := s.UpsertAssignment(ctx, tenantID, assignment); err != nil {
|
|
if errors.Is(err, ErrConflict) {
|
|
continue
|
|
}
|
|
return ExchangeSummary{}, err
|
|
}
|
|
}
|
|
return exchange.Summary(), nil
|
|
}
|