github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/client/controllers/cont_camps.go

package controllers

import (
	"errors"
	"fmt"
	"net/http"
	"sort"
	"strconv"
	"time"

	"github.com/benoitkugler/goACVE/server/core/apiserver"
	dm "github.com/benoitkugler/goACVE/server/core/datamodel"
	"github.com/benoitkugler/goACVE/server/core/documents"
	rd "github.com/benoitkugler/goACVE/server/core/rawdata"
	"github.com/benoitkugler/goACVE/server/core/utils/table"
)

var HeadersResponsables = []rd.Header{
	{Field: dm.ParticipantRespoNom, Label: "Nom"},
	{Field: dm.ParticipantRespoPrenom, Label: "Prénom"},
	{Field: dm.ParticipantRespoMail, Label: "Mail"},
	{Field: dm.ParticipantRespoTelsLines, Label: "Téléphones"},
	{Field: dm.ParticipantRespoAdresse, Label: "Adresse"},
	{Field: dm.ParticipantRespoCodePostal, Label: "Code postal"},
	{Field: dm.ParticipantRespoVille, Label: "Ville"},
}

type ButtonsCamps struct {
	CreerParticipant, SupprimerParticipant, ChangerParticipant, VerifieAttente, ExporterParticipants EtatSideButton
}

type OngletCamps interface {
	baseOnglet

	ConfirmeNotifPlaceLiberee(info string) (keep bool, notifie bool)
	ConfirmeAjoutParticipant(camp dm.AccesCamp, personne rd.Personne, causes []string) bool
	ConfirmeSupprimeParticipant(msg string) bool
}

type EtatCamps struct {
	CampCurrent         rd.IId
	ShowCampsTerminated bool

	IdParticipant rd.IId // simple ou complet
}

type Camps struct {
	Onglet         OngletCamps
	main           *MainController
	ListeCamps     rd.Table
	ListeInscrits  rd.Table
	ListeAttente   rd.Table
	HeaderInscrits []rd.Header
	HeaderAttente  []rd.Header
	Base           *dm.BaseLocale
	Etat           EtatCamps

	// Droit d'édition/ajout participant,
	// Droit de modification partielle des infos du camp
	ParticipantsRight, CampsRight bool
}

func NewCamps(main *MainController, permission int) *Camps {
	c := Camps{main: main, Base: main.Base, ParticipantsRight: permission >= 2,
		CampsRight: permission >= 3,
		HeaderAttente: []rd.Header{
			{Field: dm.PersonneNom, Label: "Nom"},
			{Field: dm.PersonnePrenom, Label: "Prénom"},
			{Field: dm.PersonneSexe, Label: "Sexe"},
			{Field: dm.ParticipantAgeDebutCamp, Label: "Age au début du camp"},
			{Field: dm.PersonneDateNaissance, Label: "Date de naissance"},
			{Field: dm.ParticipantRaisonAttente, Label: "Statut"},
		},
		HeaderInscrits: []rd.Header{
			{Field: dm.PersonneNom, Label: "Nom"},
			{Field: dm.PersonnePrenom, Label: "Prénom"},
			{Field: dm.PersonneSexe, Label: "Sexe"},
			{Field: dm.ParticipantAgeDebutCamp, Label: "Age au début du camp"},
			{Field: dm.PersonneDateNaissance, Label: "Date de naissance"},
			{Field: dm.ParticipantGroupe, Label: "Groupe"},
			{Field: dm.ParticipantBus, Label: "Navette"},
			{Field: dm.ParticipantMaterielSki, Label: "Matériel de ski"},
		},
	}
	c.resetData()
	return &c
}

func (c *Camps) resetData() {
	isTerminated := rd.OBNon
	if c.Etat.ShowCampsTerminated {
		isTerminated = 0
	}
	tmp := c.Base.GetCamps(false, isTerminated)
	sort.Slice(tmp, func(i, j int) bool { // ordre déterministique
		return tmp[i].Id < tmp[j].Id
	})
	sort.SliceStable(tmp, func(i, j int) bool {
		return tmp[i].RawData().DateDebut.Time().Before(tmp[j].RawData().DateDebut.Time())
	})
	sort.SliceStable(tmp, func(i, j int) bool {
		return bool(tmp[i].RawData().Ouvert || !tmp[j].RawData().Ouvert)
	})

	_, cache1 := c.Base.ResoudParticipants()
	cache2 := c.Base.ResoudParticipantsimples()
	c.ListeCamps = make(rd.Table, len(tmp))
	for index, camp := range tmp {
		c.ListeCamps[index] = camp.AsItem(cache1, cache2)
	}

	// besoin de déselectionner si absent des camps affichés
	if c.Etat.CampCurrent != nil && !HasId(c.ListeCamps, c.Etat.CampCurrent) {
		c.Etat.CampCurrent = nil
	}

	partCurrentInListe := false
	if idCamp := c.Etat.CampCurrent; idCamp != nil {
		camp := c.Base.NewCamp(idCamp.Int64())
		c.ListeInscrits, c.ListeAttente = camp.GetListes(false, "", false, false)
		partCurrent := c.Etat.IdParticipant
		if partCurrent != nil && (HasId(c.ListeInscrits, partCurrent) || HasId(c.ListeAttente, partCurrent)) {
			partCurrentInListe = true
		}
	}
	// besoin de déselectionner si absent des participants affichés
	if !partCurrentInListe {
		c.Etat.IdParticipant = nil
	}
}

func (c *Camps) SideButtons() ButtonsCamps {
	bs := ButtonsCamps{}
	hasCamp := ButtonPresent
	if c.Etat.CampCurrent != nil {
		hasCamp = ButtonActivated
	}
	if c.ParticipantsRight {
		bs.CreerParticipant = hasCamp

		bs.SupprimerParticipant = ButtonPresent
		bs.ChangerParticipant = ButtonPresent
		if c.Etat.IdParticipant != nil {
			bs.SupprimerParticipant = ButtonActivated
			bs.ChangerParticipant = ButtonActivated
		}
	}
	bs.ExporterParticipants = hasCamp
	bs.VerifieAttente = ButtonActivated
	return bs
}

func (c *Camps) GetStats() (out []Stat) {
	if c.Etat.CampCurrent == nil {
		return
	}
	camp := c.Base.NewCamp(c.Etat.CampCurrent.Int64())
	stats := camp.GetStats(nil, nil, nil)
	out = []Stat{
		{Label: "Nombre d'inscrits", Value: strconv.Itoa(stats.Inscrits)},
		{Label: "Nombre de places restantes", Value: strconv.Itoa(stats.PlacesRestantes)},
		{Label: "Taille de la liste d'attente", Value: strconv.Itoa(stats.Attente)},
		{Label: "Taille de l'équipe", Value: strconv.Itoa(stats.Equipe)},
		{Label: "Nombre de places réservées", Value: strconv.Itoa(stats.PlacesReservees)},
	}
	if camp.RawData().NeedEquilibreGf {
		v := "-"
		if stats.Inscrits != 0 {
			pG := stats.Garcons * 100 / stats.Inscrits
			v = fmt.Sprintf("%d/%d (%%)", pG, 100-pG)
		}
		out = append(out, Stat{Label: "Equilibre Garçons/Filles", Value: v})
	}
	return
}

func updateCamp(camp rd.Camp) (rd.Camp, error) {
	var out rd.Camp
	err := requete(apiserver.UrlCamps, http.MethodPost, camp, &out)
	return out, err
}

// UpdateCamp met à jour le profil transmis sur le serveur
func (c *Camps) UpdateCamp(camp rd.Camp) {
	job := func() (interface{}, error) {
		return updateCamp(camp)
	}
	onSuccess := func(_out interface{}) {
		out := _out.(rd.Camp)
		c.Base.Camps[out.Id] = out
		c.main.ShowStandard(fmt.Sprintf("Camp %s mis à jour avec succès.", out.Label()), false)
		c.main.ResetAllControllers()
	}
	c.main.ShowStandard("Mise à jour du camp...", true)
	c.main.Background.Run(job, onSuccess)
}

// UpdateParticipant met à jour de profil transmis sur le serveur, de manière SYNCHRONE.
// Gère l'erreur et la modification de la base locale.
func (c *Camps) UpdateParticipant(part rd.Participant) *dm.AccesParticipant {
	c.main.ShowStandard("Mise à jour du participant...", true)
	var out apiserver.CreateParticipantOut
	if err := requete(apiserver.UrlParticipants, http.MethodPost, part, &out); err != nil {
		c.main.ShowError(err)
		return nil
	}

	c.Base.ApplyCreateParticipant(out)
	c.main.ShowStandard("Participant mis à jour avec succès.", false)
	c.main.ResetAllControllers()
	ac := c.Base.NewParticipant(out.Participant.Id)
	return &ac
}

// UpdateParticipantsimple met à jour de profil transmis sur le serveur, de manière SYNCHRONE.
// Gère l'erreur et la modification de la base locale.
func (c *Camps) UpdateParticipantsimple(part rd.Participantsimple) *dm.AccesParticipantsimple {
	c.main.ShowStandard("Mise à jour du participant...", true)
	var out rd.Participantsimple
	if err := requete(apiserver.UrlParticipantsimples, http.MethodPost, part, &out); err != nil {
		c.main.ShowError(err)
		return nil
	}

	c.Base.Participantsimples[out.Id] = out
	c.main.ShowStandard("Participant mis à jour avec succès.", false)
	c.main.ResetAllControllers()
	ac := c.Base.NewParticipantsimple(out.Id)
	return &ac
}

func (c *Camps) SupprimeParticipantCourant() {
	switch idPart := c.Etat.IdParticipant.(type) {
	case rd.IdParticipant:
		c.SupprimeParticipant(c.Base.NewParticipant(idPart.Int64()), false)
	case rd.IdParticipantsimple:
		c.supprimeParticipantsimple(c.Base.NewParticipantsimple(idPart.Int64()))
	}
}

// SupprimeParticipant demande la suppression au serveur,
// après avoir averti l'utilisateur.
// Effectue un reset général.
func (c *Camps) SupprimeParticipant(part dm.AccesParticipant, synchrone bool) {
	message := fmt.Sprintf("Suppression de <b>%s</b> du camp %s <br/><br/>", part.GetPersonne().RawData().NomPrenom(),
		part.GetCamp().RawData().Label())

	fac, hasFacture := part.GetFacture()
	if hasFacture {
		message += "Le participant sera <b>supprimé et retiré du dossier</b> associé. <br/>"
		if len(fac.GetDossiers(nil)) == 1 { // dernier dossier
			message += "Attention, le dossier sera vide.  Si vous pensez ne plus" +
				" travailler avec ce dossier, pensez à le supprimer (Onglet Suivi des dossiers). <br/>"
		}
	} else {
		message += "Le participant sera <b>supprimé</b>. <br/>"
	}
	aides := part.GetAides(nil)
	if len(aides) == 1 {
		message += "<i>Une aide liée</i> au participant sera aussi supprimée."
	} else if len(aides) > 1 {
		message += fmt.Sprintf("<br/> <i>%d aides liées</i> au participant seront aussi supprimées.", len(aides))
	}

	if !c.Onglet.ConfirmeSupprimeParticipant(message) {
		c.main.ShowStandard("Suppression annulée.", false)
		return
	}

	job := func() (interface{}, error) {
		var out apiserver.DeleteParticipantOut
		err := requete(apiserver.UrlParticipants, http.MethodDelete, IdAsParams(part.Id), &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(apiserver.DeleteParticipantOut)
		c.Base.CleanupParticipant(out)
		msg := "Participant supprimé avec succès."
		if len(out.IdsAides) > 0 {
			msg += fmt.Sprintf(" %d aide(s) associées également supprimées.", len(out.IdsAides))
		}
		if out.IdPersonne >= 0 {
			msg += " Personne temporaire supprimée."
		}
		c.main.ShowStandard(msg, false)
		c.main.ResetAllControllers()
	}
	c.main.ShowStandard("Suppression du participant...", true)
	background := c.main.Background
	if synchrone {
		background = SequentialBackground{OnError: c.main.ShowError}
	}
	background.Run(job, onSuccess)
}

// supprimeParticipantsimple demande la suppression au serveur (asynchrone),
// après avoir averti l'utilisateur.
// Effectue un reset général.
func (c *Camps) supprimeParticipantsimple(part dm.AccesParticipantsimple) bool {
	message := fmt.Sprintf("Suppression de <b>%s</b> du camp %s <br/><br/>", part.GetPersonne().RawData().NomPrenom(),
		part.GetCamp().RawData().Label())

	if !c.Onglet.ConfirmeSupprimeParticipant(message) {
		c.main.ShowStandard("Suppression annulée.", false)
		return false
	}

	job := func() (interface{}, error) {
		var out rd.Participantsimple
		err := requete(apiserver.UrlParticipantsimples, http.MethodDelete, IdAsParams(part.Id), &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(rd.Participantsimple)
		delete(c.Base.Participantsimples, out.Id)
		c.main.ShowStandard("Participant supprimé avec succès.", false)
		c.main.ResetAllControllers()

	}
	c.main.ShowStandard("Suppression du participant...", true)
	c.main.Background.Run(job, onSuccess)
	return true
}

func (c *Camps) checkParticipant(participant rd.Participant) (keep bool) {
	personne := c.Base.Personnes[participant.IdPersonne]
	camp := c.Base.NewCamp(participant.IdCamp)
	if c.Base.IsParticipantAlreadyHere(personne.Id, camp.Id) {
		c.main.ShowError(fmt.Errorf("%s est déjà présent(e) au camp %s", personne.NomPrenom(),
			camp.RawData().Label()))
		return false
	}
	hints := camp.HintsAttente(participant.IdPersonne, participant.ListeAttente.Statut == rd.Inscrit)
	if hints.Hint() != rd.Inscrit && !c.Onglet.ConfirmeAjoutParticipant(camp, personne, hints.Causes()) {
		c.main.ShowStandard("Ajout annulé.", false)
		return false
	}
	return true
}

// CreeParticipant ajoute le participant donné, après vérification
func (c *Camps) CreeParticipant(participant rd.Participant) {
	if !c.checkParticipant(participant) {
		return
	}

	participant.DateHeure = rd.Time(time.Now())
	job := func() (interface{}, error) {
		var out apiserver.CreateParticipantOut
		err := requete(apiserver.UrlParticipants, http.MethodPut, participant, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(apiserver.CreateParticipantOut)
		c.Base.ApplyCreateParticipant(out)
		c.main.ShowStandard("Participant ajouté avec succès.", false)
		c.main.ResetAllControllers()

	}
	c.main.ShowStandard("Ajout du participant en cours...", true)
	c.main.Background.Run(job, onSuccess)
}

// CreeParticipantsimple ajoute un participant au camp donné.
func (c *Camps) CreeParticipantsimple(participant rd.Participantsimple) {
	if c.Base.IsParticipantAlreadyHere(participant.IdPersonne, participant.IdCamp) {
		personne, camp := c.Base.Personnes[participant.IdPersonne], c.Base.Camps[participant.IdCamp]
		c.main.ShowError(fmt.Errorf("%s est déjà présent(e) au camp %s", personne.NomPrenom(),
			camp.Label()))
		return
	}

	participant.DateHeure = rd.Time(time.Now())

	job := func() (interface{}, error) {
		var out rd.Participantsimple
		err := requete(apiserver.UrlParticipantsimples, http.MethodPut, participant, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(rd.Participantsimple)
		c.Base.Participantsimples[out.Id] = out
		c.main.ShowStandard("Participant ajouté avec succès.", false)
		c.main.ResetAllControllers()

	}
	c.main.ShowStandard("Ajout du participant en cours...", true)
	c.main.Background.Run(job, onSuccess)
}

// MoveToInscrits effectue les vérifications, puis demande propose d'envoyer un mail de notification.
// La rotation `_attente` -> `_attente_reponse` -> `_campeur` est appliquée.
// Si `notifie` vaut `false` ou si le participant n'a pas de dossier,
// le rôle `_attente_reponse` est sauté.
// La participant peut être placé manuellement en `_attente_reponse` sans envoyer de mail
// en modifiant son rôle directement.
func (c *Camps) MoveToInscrits(id rd.IId) {
	idParticipant, ok := id.(rd.IdParticipant)
	if !ok {
		c.main.ShowError(errors.New("Fonctionnalité réservé aux séjours normaux."))
		return
	}
	participant := c.Base.NewParticipant(idParticipant.Int64())
	personne, camp := participant.GetPersonne(), participant.GetCamp()

	hints := camp.HintsAttente(personne.Id, true)
	if hints.Hint() != rd.Inscrit && !c.Onglet.ConfirmeAjoutParticipant(camp, personne.RawData(), hints.Causes()) {
		c.main.ShowStandard("Passage dans les inscrits annulé.", false)
		return
	}

	raw := participant.RawData()
	fac, HasFac := participant.GetFacture()
	if !HasFac {
		raw.ListeAttente = rd.ListeAttente{}
		c.UpdateParticipant(raw)
		return
	}

	var newRole = rd.AttenteReponse
	info := "Voulez-vous envoyer un message indiquant qu'une place s'est libérée et demandant une réponse ?"
	if raw.ListeAttente.Statut == rd.AttenteReponse {
		newRole = rd.Inscrit
		info = "Voulez-vous envoyer un message confirmant l'inscription ?"
	}

	keep, notifie := c.Onglet.ConfirmeNotifPlaceLiberee(info)
	if !keep {
		c.main.ShowStandard("Passage dans les inscrits annulé.", false)
		return
	}
	if !notifie { // simple modification, équivalente à changer le rôle directement
		raw.ListeAttente = rd.ListeAttente{}
		c.UpdateParticipant(raw)
		return
	}
	c.main.Controllers.SuiviDossiers.EnvoiPlaceLiberee(fac, participant.Id, newRole)
}

func (c *Camps) ExportParticipants(bus rd.Bus, triGroupe, showAttente bool) (filepath string) {
	if c.Etat.CampCurrent == nil {
		c.main.ShowError(errors.New("Aucun camp actuel !"))
		return ""
	}
	camp := c.Base.NewCamp(c.Etat.CampCurrent.Int64())
	inscrits, attente := camp.GetListes(triGroupe, bus, true, false)
	if !showAttente {
		attente = nil
	}
	if len(inscrits)+len(attente) == 0 {
		c.main.ShowError(errors.New("Aucun participant à exporter."))
		return
	}
	filepath, err := table.EnregistreListeParticipants(c.HeaderInscrits, HeadersResponsables, inscrits, attente,
		true, string(camp.RawData().Nom), LocalFolder)
	if err != nil {
		c.main.ShowError(fmt.Errorf("Impossible de générer la liste : %s", err))
		return ""
	}
	c.main.ShowStandard(fmt.Sprintf("Liste des participants générée dans %s", filepath), false)
	return filepath
}

// ChangeCamp effectue les vérifications puis change le participant courant de camp,
// de manière SYNCHRONE.
func (c *Camps) ChangeCamp(idCamp int64) {
	if c.Etat.CampCurrent == nil || c.Etat.IdParticipant == nil {
		c.main.ShowError(errors.New("Aucun camp courant."))
		return
	}
	isSimple := c.Base.Camps[c.Etat.CampCurrent.Int64()].InscriptionSimple
	if isSimple {
		c.main.ShowError(errors.New("Le camp courant ne supporte pas cette fonction."))
		return
	}
	isTargetSimple := c.Base.Camps[idCamp].InscriptionSimple
	if isTargetSimple {
		c.main.ShowError(errors.New("Le champ choisi propose une inscription simplifiée."))
		return
	}

	rawPart := c.Base.NewParticipant(c.Etat.IdParticipant.Int64()).RawData()
	rawPart.IdCamp = idCamp // on passe sur le camp cible
	if !c.checkParticipant(rawPart) {
		return
	}
	rawPart.DateHeure = rd.Time(time.Now())
	c.UpdateParticipant(rawPart)
}

// SelectCamp sélectionne le camp donné
func (c *Camps) SelectCamp(camp int64) {
	c.Etat.CampCurrent = rd.Id(camp)
	if c.Base.Camps[camp].IsTerminated() { // besoin d'afficher les camps terminés
		c.Etat.ShowCampsTerminated = true
	}
	c.Onglet.GrabFocus()
	c.Reset() // le camp courant a changé, besoin des listes, etc..
}

// SelectParticipant sélectionne le participant donné, en changeant le camp courant
// si nécessaire.
func (c *Camps) SelectParticipant(part dm.Inscrit) {
	camp := part.GetCamp()
	c.Etat.CampCurrent = rd.Id(camp.Id)
	c.Etat.IdParticipant = part.GetId()
	if camp.RawData().IsTerminated() { // besoin d'afficher les camps terminés
		c.Etat.ShowCampsTerminated = true
	}
	c.Onglet.GrabFocus()
	// le camp courant a changé, besoin des listes, etc..
	c.Reset()
	// si l'onglet Camp n'a pas encore été utilisé, la liste ne scroll pas sans ce deuxième appel
	c.Reset()
}

func (c *Camps) ExportSuiviFinancier(camp int64) string {
	return c.main.Controllers.SuiviCamps.ExportSuiviFinancierParticipants(c.Base.NewCamp(camp))
}

// NotifieDirecteur envoie un mail (asynchrone)
func (c *MainController) NotifieDirecteur(to, html string) {
	job := func() (interface{}, error) {
		var out string
		err := requete(apiserver.UrlMailsSimple, http.MethodPost, apiserver.ParamsSimpleMail{
			Html: html, To: to, Subject: "[ACVE] Message privé",
		}, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(string)
		c.ShowStandard(out, false)
	}
	c.ShowStandard("Notification du directeur...", true)
	c.Background.Run(job, onSuccess)
}

type DiagnosticListeAttente struct {
	Participant dm.AccesParticipant
	Hint        rd.StatutAttente
}

// CheckListeAttentes compare les listes d'attentes
// réelles avec celles calculées automatiquement et émet un diagnostic
// en camp de différence :
//	- optionnel, pour les participants déjà en liste principal
//	- impératif, pour les participants encore en liste d'attente
func (c *Camps) CheckListeAttentes() (inscrits, attentes []DiagnosticListeAttente) {
	_, cache := c.Base.ResoudParticipants()
	for idParticipant, part := range c.Base.Participants {
		acPart := c.Base.NewParticipant(idParticipant)
		hint := acPart.HintsAttente(cache).Hint()
		actuel := part.ListeAttente.Statut
		if actuel == rd.AttenteReponse { // situation temporaire, on ne dit rien
			continue
		}
		if hint == actuel { // tout va bien
			continue
		}
		if part.ListeAttente.Raison != "" {
			// on ignore les participants avec une raison spéciale
			continue
		}
		diag := DiagnosticListeAttente{Participant: acPart, Hint: hint}
		if actuel == rd.Inscrit {
			inscrits = append(inscrits, diag)
		} else {
			attentes = append(attentes, diag)
		}
	}
	sortDiags := func(l []DiagnosticListeAttente) {
		sort.Slice(l, func(i, j int) bool {
			return l[i].Participant.Id < l[j].Participant.Id
		})
		sort.SliceStable(l, func(i, j int) bool {
			return l[i].Participant.GetCamp().Id < l[j].Participant.GetCamp().Id
		})
	}
	sortDiags(inscrits)
	sortDiags(attentes)
	return
}

// DocumentCamp est soit `DynamicDocument` soit `RegisteredDocument`
type DocumentCamp interface {
	FileName() string
	isDocCamp()
}

func (DynamicDocument) isDocCamp()    {}
func (RegisteredDocument) isDocCamp() {}

type DynamicDocument struct {
	documents.DynamicDocument
}

type RegisteredDocument rd.Document

func (doc RegisteredDocument) FileName() string { return doc.NomClient.String() }

// GetDocuments renvoie les metas de chaque document disponible.
// Si plusieurs lettres sont présentes dans la base, elles sont toutes renvoyées.
// Renvois systématiquement les pièces jointes additionnelles.
// L'attribut `Locked` est ignoré
func GetDocuments(ac dm.AccesCamp) (out []DocumentCamp) {
	lp := documents.NewListeParticipants(ac)
	lv := documents.NewListeVetements(ac.RawData())

	if len(lp.Liste) > 0 {
		out = append(out, DynamicDocument{DynamicDocument: lp})
	}
	if len(lv.Liste) > 0 {
		out = append(out, DynamicDocument{DynamicDocument: lv})
	}
	for _, doc := range ac.GetRegisteredDocuments(true, true) {
		out = append(out, RegisteredDocument(doc))
	}
	return out
}