github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/server/acvegestion/controller.go

// Expose les fonctionnalités requises par le client 'lourd' Controller
// Le client implémente sa propre logique en terme de lecture des données,
// mais délègue les modifications au serveur.
package acvegestion

import (
	"database/sql"
	"encoding/json"
	"fmt"
	"net/http"
	"strings"
	"time"

	"github.com/benoitkugler/goACVE/server/logiciel"
	"github.com/benoitkugler/goACVE/server/shared"

	"github.com/benoitkugler/goACVE/logs"
	"github.com/benoitkugler/goACVE/server/core/apiserver"
	rd "github.com/benoitkugler/goACVE/server/core/rawdata"
	"github.com/benoitkugler/goACVE/server/core/rawdata/composites"
	"github.com/benoitkugler/goACVE/server/core/utils/mails"
	"github.com/labstack/echo"
)

type FicheSanitaireNotifier interface {
	SendMailPartageFicheSanitaire(host, respoMail string, participant rd.Personne) ([]string, error)
}

type Controller struct {
	shared.Controller

	FicheSanitaireNotifier FicheSanitaireNotifier
	ContraintesEquipiers   rd.Contraintes
}

func authentifie(context echo.Context) error {
	username, password, ok := context.Request().BasicAuth()
	if ok && username == apiserver.BasicAuthUsername && password == logs.APIKEY {
		return nil
	}
	return echo.ErrUnauthorized
}

// SertUpdateInfos renvoie les versions disponibles
func SertUpdateInfos(c echo.Context) error {
	infos, err := logiciel.GetUpdateInfos(c.Param("platform"))
	if err != nil {
		return err
	}
	return c.JSONPretty(200, infos, "  ")
}

// SertUpdate renvoie la mise à jour compressée correspondant à la demande
func SertUpdate(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	path, err := logiciel.GetUpdate(c.Param("platform"))
	if err != nil {
		return err
	}
	return c.File(path)
}

// db est utile pour trouver le contact
func (ct Controller) mailFromMessage(host string, db rd.DB, message rd.Message) error {
	facture, err := rd.SelectFacture(db, message.IdFacture)
	if err != nil {
		return err
	}
	personne, err := rd.SelectPersonne(db, facture.IdPersonne)
	if err != nil {
		return err
	}
	subject := fmt.Sprintf("[ACVE] - %s", message.Kind.MailTitle())
	contact := mails.Contact{
		Prenom: personne.FPrenom(),
		Sexe:   personne.Sexe,
	}
	contenu := contenus[message.Kind]
	url := shared.BuildUrl(host, facture.UrlEspacePerso("espace_perso"), nil)
	body, err := mails.NewNotifieMessage(contact, message.Kind.MailTitle(), contenu, url)
	if err != nil {
		return err
	}
	to := personne.Mail.String()
	err = mails.NewMailer(ct.SMTP).SendMail(to, subject, body, facture.CopiesMails, nil)
	return err
}

// ajoute un message et envoie un mail
func (ct Controller) creeMessageCentre(host string, idFacture int64, contenu rd.String) (apiserver.NotifieMessageOut, error) {
	tx, err := ct.DB.Begin()
	if err != nil {
		return apiserver.NotifieMessageOut{}, err
	}
	var out apiserver.NotifieMessageOut
	out.Message = rd.Message{IdFacture: idFacture, Kind: rd.MCentre, Created: rd.Time(time.Now())}
	out.Message, err = out.Message.Insert(tx)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	out.MessageMessage = rd.MessageMessage{IdMessage: out.Message.Id, Contenu: contenu, GuardKind: rd.MCentre}
	err = rd.InsertManyMessageMessages(tx, out.MessageMessage)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	err = ct.mailFromMessage(host, tx, out.Message)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return out, err
}

func (ct Controller) editMessageCentre(params apiserver.EditMessageIn) (apiserver.EditMessageOut, error) {
	var out apiserver.EditMessageOut
	tx, err := ct.DB.Begin()
	if err != nil {
		return out, err
	}
	rows, err := tx.Query("UPDATE message_messages SET contenu = $1 WHERE id_message = ANY($2) RETURNING *", params.Contenu, params.IdMessages.AsSQL())
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	out.MessageMessages, err = rd.ScanMessageMessages(rows)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	rows, err = tx.Query("UPDATE messages SET modified = now() WHERE id = ANY($1) RETURNING *", params.IdMessages.AsSQL())
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	out.Messages, err = rd.ScanMessages(rows)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return out, err
}

func (ct Controller) createMessageMessage(params apiserver.CreateMessageMessage) (apiserver.CreateMessageMessage, error) {
	tx, err := ct.DB.Begin()
	if err != nil {
		return params, err
	}
	params.Message, err = params.Message.Insert(tx)
	if err != nil {
		return params, shared.Rollback(tx, err)
	}
	params.MessageMessage.IdMessage = params.Message.Id
	err = rd.InsertManyMessageMessages(tx, params.MessageMessage)
	if err != nil {
		return params, shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return params, err
}

func (ct Controller) notifieSimple(host string, params apiserver.NotifieSimple) (rd.Message, error) {
	tx, err := ct.DB.Begin()
	if err != nil {
		return rd.Message{}, err
	}
	message := rd.Message{IdFacture: params.IdFacture, Kind: params.Kind, Created: rd.Time(time.Now())}
	message, err = message.Insert(tx)
	if err != nil {
		return rd.Message{}, shared.Rollback(tx, err)
	}
	err = ct.mailFromMessage(host, tx, message)
	if err != nil {
		return rd.Message{}, shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return message, err
}

func (ct Controller) notifiePlaceLiberee(host string, params apiserver.NotifiePlaceLibereeIn) (apiserver.NotifiePlaceLibereeOut, error) {
	var out apiserver.NotifiePlaceLibereeOut

	tx, err := ct.DB.Begin()
	if err != nil {
		return out, err
	}

	// on met à jour le participant
	participant, err := rd.SelectParticipant(tx, params.IdParticipant)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	if participant.IdFacture.IsNil() {
		err = fmt.Errorf("Le participant (%d) n'est pas lié à un dossier !", participant.Id)
		return out, shared.Rollback(tx, err)
	}

	participant.ListeAttente.Statut = params.NewStatut
	out.Participant, err = participant.Update(tx)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}

	// on insert le message et ses détails
	out.Message = rd.Message{
		IdFacture: participant.IdFacture.Int64,
		Kind:      rd.MPlaceLiberee,
		Created:   rd.Time(time.Now()),
	}
	out.Message, err = out.Message.Insert(tx)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	out.Details = rd.MessagePlacelibere{
		IdMessage:     out.Message.Id,
		IdParticipant: participant.Id,
	}
	err = rd.InsertManyMessagePlaceliberes(tx, out.Details)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}

	// finalement on envoie le mail
	err = ct.mailFromMessage(host, tx, out.Message)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}

	err = tx.Commit()
	return out, err
}

func (ct Controller) notifieAttestation(host string, params apiserver.NotifieAttestationIn) (apiserver.NotifieAttestationOut, error) {
	var out apiserver.NotifieAttestationOut
	if !(params.Kind == rd.MFactureAcquittee || params.Kind == rd.MAttestationPresence) {
		return out, fmt.Errorf("Un message d'attestation est attendu : reçu %s", params.Kind)
	}

	tx, err := ct.DB.Begin()
	if err != nil {
		return out, err
	}
	out.Message = rd.Message{IdFacture: params.IdFacture, Kind: params.Kind, Created: rd.Time(time.Now())}
	out.Message, err = out.Message.Insert(tx)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	out.MessageAttestation = rd.MessageAttestation{IdMessage: out.Message.Id, Distribution: rd.DMail, GuardKind: out.Message.Kind}
	err = rd.InsertManyMessageAttestations(tx, out.MessageAttestation)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	err = ct.mailFromMessage(host, tx, out.Message)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return out, err
}

type streamMailer interface {
	// streamOut must never be nil
	insertMessageComplement(message rd.Message, tx *sql.Tx) (interface{}, error)
}

type streamMessage struct {
	contenu rd.String
}

func (b streamMessage) insertMessageComplement(message rd.Message, tx *sql.Tx) (interface{}, error) {
	var (
		out apiserver.NotifieManyOut
		err error
	)
	out.Message = message
	out.MessageMessage = rd.MessageMessage{IdMessage: out.Message.Id, Contenu: b.contenu, GuardKind: rd.MCentre}
	err = rd.InsertManyMessageMessages(tx, out.MessageMessage)
	return out, err
}

// checkVerrouDocuments renvoie une erreur si l'envoi est encore vérouillé
func (ct Controller) checkVerrouDocuments(idCamp int64) error {
	camp, err := rd.SelectCamp(ct.DB, idCamp)
	if err != nil {
		return err
	}
	return camp.CheckEnvoisLock()
}

type streamDocument struct {
	idCamp int64
}

// vérifie que tous les dossiers ont au moins un participant
// au séjour (pas en liste d'attente)
func (b streamDocument) checkListeAttente(factures rd.Ids, db rd.DB) error {
	participants, err := rd.SelectParticipantsByIdFactures(db, factures...)
	if err != nil {
		return err
	}
	liens, _ := participants.Resoud() // par facture
	for _, idFacture := range factures {
		isOK := false
		for _, idParticipant := range liens[idFacture] {
			part := participants[idParticipant]
			isInscritCamp := part.IdCamp == b.idCamp && part.ListeAttente.IsInscrit()
			if isInscritCamp {
				isOK = true
				break
			}
		}
		if !isOK {
			return fmt.Errorf("Un dossier (id %d) n'a aucun participant en liste principale.", idFacture)
		}
	}
	return nil
}

func (b streamDocument) insertMessageComplement(message rd.Message, tx *sql.Tx) (interface{}, error) {
	var (
		out apiserver.NotifieDocumentsOut
		err error
	)
	out.Message = message
	out.MessageCamp = rd.MessageDocument{IdMessage: out.Message.Id, IdCamp: b.idCamp}
	err = rd.InsertManyMessageDocuments(tx, out.MessageCamp)
	return out, err
}

type streamSondage struct {
	idCamp int64
}

func (b streamSondage) insertMessageComplement(message rd.Message, tx *sql.Tx) (interface{}, error) {
	var (
		out apiserver.NotifieSondagesOut
		err error
	)
	out.Message = message
	out.MessageSondage = rd.MessageSondage{IdMessage: out.Message.Id, IdCamp: b.idCamp}
	err = rd.InsertManyMessageSondages(tx, out.MessageSondage)
	return out, err
}

func (ct Controller) notifieManyMessages(host string, mailer streamMailer, message rd.Message, dossiers rd.Ids, resp *echo.Response) error {
	pool, err := mails.NewPool(ct.SMTP, nil)
	if err != nil {
		return err
	}
	defer pool.Close()

	// Streaming status between each mails
	resp.Header().Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
	resp.WriteHeader(http.StatusOK)

	oneMail := func(message rd.Message) (interface{}, error) {
		tx, err := ct.DB.Begin()
		if err != nil {
			return nil, err
		}

		message, err = message.Insert(tx)
		if err != nil {
			return nil, shared.Rollback(tx, err)
		}
		out, err := mailer.insertMessageComplement(message, tx)
		if err != nil {
			return out, shared.Rollback(tx, err)
		}

		err = ct.mailFromMessage(host, tx, message)
		if err != nil {
			return out, shared.Rollback(tx, err)
		}
		err = tx.Commit()
		return out, err
	}

	message.Created = rd.Time(time.Now())
	for _, dossier := range dossiers {
		// on duplique le message
		message.IdFacture = dossier

		data, err := oneMail(message)
		out := apiserver.StreamOut{Data: data}
		if err != nil {
			out.Error = err.Error()
		}

		if err := json.NewEncoder(resp).Encode(out); err != nil {
			// impossible d'écrire le résultat, on interrompt complètement
			return err
		}
		resp.Flush()
	}
	return nil
}

// supprime aussi les aides (et leurs justificatifs)
// si le participant est temporaire, supprime aussi la personne associée
// ne commit pas, ne rollback pas
func deleteOneParticipant(tx rd.DB, id int64) (apiserver.DeleteParticipantOut, error) {
	out := apiserver.DeleteParticipantOut{IdParticipant: id}

	// liens documents
	rows, err := tx.Query(`DELETE FROM document_aides 
	USING aides WHERE aides.id = document_aides.id_aide AND aides.id_participant = $1
	RETURNING document_aides.id_document`, id)
	if err != nil {
		return out, err
	}
	out.IdsDocuments, err = rd.ScanIds(rows)
	if err != nil {
		return out, err
	}

	_, err = rd.DeleteDocumentsByIds(tx, out.IdsDocuments...)
	if err != nil {
		return out, err
	}

	out.IdsAides, err = rd.DeleteAidesByIdParticipants(tx, id)
	if err != nil {
		return out, err
	}

	// on supprime aussi les messages Place libérée
	rows, err = tx.Query("DELETE FROM message_placeliberes WHERE id_participant = $1 RETURNING id_message", id)
	if err != nil {
		return out, err
	}
	idMessages, err := rd.ScanIds(rows)
	if err != nil {
		return out, err
	}
	out.IdsMessages, err = rd.DeleteMessagesByIds(tx, idMessages...)
	if err != nil {
		return out, err
	}

	part, err := rd.DeleteParticipantById(tx, id)
	if err != nil {
		return out, err
	}

	isTmp, docs, err := shared.DeletePersonne(tx, part.IdPersonne)
	if err != nil {
		return out, err
	}
	out.IdsDocuments = append(out.IdsDocuments, docs...)

	// si la personne était temporaire
	out.IdPersonne = -1
	if isTmp {
		out.IdPersonne = part.IdPersonne
	}

	return out, nil
}

// supprime le dossier, les paiments, les participants, les aides
// et les personnes temporaires associés
func (ct Controller) deleteInscription(idFacture int64) (apiserver.DeleteInscriptionOut, error) {
	var out apiserver.DeleteInscriptionOut
	tx, err := ct.DB.Begin()
	if err != nil {
		return out, err
	}

	out.IdsPaiements, err = rd.DeletePaiementsByIdFactures(tx, idFacture)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}

	rows, err := tx.Query("SELECT id FROM participants WHERE id_facture = $1", idFacture)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	idParts, err := rd.ScanIds(rows)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	out.Participants = make([]apiserver.DeleteParticipantOut, len(idParts))
	for index, idPart := range idParts {
		out.Participants[index], err = deleteOneParticipant(tx, idPart)
		if err != nil {
			return out, shared.Rollback(tx, err)
		}
	}

	facture, err := rd.DeleteFactureById(tx, idFacture)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}

	// responsable
	isTmp, docs, err := shared.DeletePersonne(tx, facture.IdPersonne)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	out.IdsDocuments = docs
	out.IdResponsable = facture.IdPersonne
	if isTmp {
		out.IdResponsable = -1
	}
	err = tx.Commit()
	return out, err
}

// envoi un mail de confirmation après identification d'une inscription simple
func (ct Controller) notifieInscriptionSimpleValide(part rd.Participantsimple) error {
	personne, err := rd.SelectPersonne(ct.DB, part.IdPersonne)
	if err != nil {
		return err
	}
	camp, err := rd.SelectCamp(ct.DB, part.IdCamp)
	if err != nil {
		return err
	}

	mailHtml, err := mails.NewAccuseReceptionSimple(camp, mails.Contact{
		Prenom: personne.FPrenom(),
		Sexe:   personne.Sexe,
	})
	if err != nil {
		return err
	}
	err = mails.NewMailer(ct.SMTP).SendMail(personne.Mail.String(), "[ACVE] Inscription validée", mailHtml,
		nil, mails.CustomReplyTo(rd.CoordonnesCentre.Mail))
	return err
}

// vérifie si les participants vont avoir besoin de débloquer la fiche sanitaire
// Si oui, envoi un mail aux propriétaires
func (ct Controller) checkNotifiePartageFicheSanitaire(host string, idFacture int64) error {
	row := ct.DB.QueryRow(`SELECT factures.*, personnes.* FROM factures 
		JOIN personnes ON factures.id_personne = personnes.id
		WHERE factures.id = $1`, idFacture)
	responsable, err := composites.ScanFacturePersonne(row)
	if err != nil {
		return err
	}

	rows, err := ct.DB.Query(`SELECT participants.*, personnes.* FROM participants 
	JOIN personnes ON participants.id_personne = personnes.id
	WHERE participants.id_facture = $1`, idFacture)
	if err != nil {
		return err
	}
	participants, err := composites.ScanParticipantPersonnes(rows)
	if err != nil {
		return err
	}

	withCamps, err := participants.LoadCamps(ct.DB)
	if err != nil {
		return err
	}
	lookup := participants.LookupToPersonnes()

	// on se ramène aux personnes sous-jacentes et on s'assure de l'unicité
	personnes := rd.Personnes{}
	for _, part := range withCamps {
		// on ignore les participants en liste d'attente
		if !part.ListeAttente.IsInscrit() {
			continue
		}

		personne := lookup[part.Participant.Id]
		age := part.Camp.AgeDebutCamp(personne.BasePersonne)
		if age.Age() >= 18 { // on ignore les participants majeurs
			continue
		}
		personnes[part.IdPersonne] = personne
	}

	mailRespo := responsable.Personne.Mail.ToLower()
	for _, personne := range personnes {
		mailsKnown := personne.FicheSanitaire.Mails
		isUnlocked := len(mailsKnown) == 0 // si aucun mail, on autorise, sinon on check
		for _, mailOk := range mailsKnown {
			if strings.ToLower(mailOk) == mailRespo {
				// Ok, le responsable est autorisé
				isUnlocked = true
				break
			}
		}

		if !isUnlocked { // on envoie un mail de déverouillage
			mailErrors, err := ct.FicheSanitaireNotifier.SendMailPartageFicheSanitaire(host, mailRespo, personne)
			if err != nil {
				return err
			}
			// on résume l'erreur
			if len(mailErrors) > 0 {
				return fmt.Errorf("Erreur pendant l'envoi des mails de partage d'une fiche sanitaire : <br/> %s",
					strings.Join(mailErrors, "<br/>"))
			}
		}
	}
	return nil
}

// rattache les paiements/participants/messages/sondages à l'autre dossier, et notifie (en option)
func (ct Controller) fusionneFactures(host string, params apiserver.FusionneFacturesIn) (out apiserver.FusionneFacturesOut, err error) {
	tx, err := ct.DB.Begin()
	if err != nil {
		return out, err
	}

	// participants
	rows, err := tx.Query("UPDATE participants SET id_facture = $1 WHERE id_facture = $2 RETURNING *", params.To, params.From)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	out.Participants, err = rd.ScanParticipants(rows)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}

	// paiements
	rows, err = tx.Query("UPDATE paiements SET id_facture = $1 WHERE id_facture = $2 RETURNING *", params.To, params.From)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	out.Paiements, err = rd.ScanPaiements(rows)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}

	// messages
	rows, err = tx.Query("UPDATE messages SET id_facture = $1 WHERE id_facture = $2 RETURNING *", params.To, params.From)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	out.Messages, err = rd.ScanMessages(rows)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}

	// sondages
	out.Sondages, err = moveSondages(params, tx)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}

	// notification par mail (nécessite les 2 dossiers)
	if params.Notifie {
		err = ct.notifieFusion(host, tx, params)
		if err != nil {
			return out, shared.Rollback(tx, err)
		}
	}

	// suppression du dossier
	_, err = rd.DeleteFactureById(tx, params.From)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	out.OldId = params.From

	err = tx.Commit()
	return out, err
}

// on envoie un mail au respo de l'ancien dossier, en donnant le lien du nouveau
func (ct *Controller) notifieFusion(host string, db rd.DB, params apiserver.FusionneFacturesIn) error {
	oldFacture, err := rd.SelectFacture(db, params.From)
	if err != nil {
		return err
	}
	personne, err := rd.SelectPersonne(db, oldFacture.IdPersonne)
	if err != nil {
		return err
	}
	subject := "[ACVE] - Fusion de dossier"
	contact := mails.Contact{
		Prenom: personne.FPrenom(),
		Sexe:   personne.Sexe,
	}
	to := personne.Mail.String()

	newFacture, err := rd.SelectFacture(db, params.To)
	if err != nil {
		return err
	}
	url := shared.BuildUrl(host, newFacture.UrlEspacePerso("espace_perso"), nil)

	body, err := mails.NewNotifFusion(contact, url)
	if err != nil {
		return err
	}
	err = mails.NewMailer(ct.SMTP).SendMail(to, subject, body, oldFacture.CopiesMails, nil)
	return err
}

// une seule réponse est autorisée par sondage et dossier:
// si une réponse existe déjà, on la garde et on ignore la réponse
// du dossier à fusionner
func moveSondages(params apiserver.FusionneFacturesIn, tx rd.DB) (rd.Sondages, error) {
	rows, err := tx.Query(`UPDATE sondages AS s1 SET id_facture = $1
	WHERE s1.id_facture = $2 AND
		(SELECT count(*) FROM sondages AS s2
			WHERE s2.id_camp = s1.id_camp AND s2.id_facture = $1) = 0
	RETURNING *`,
		params.To, params.From)
	if err != nil {
		return nil, err
	}
	return rd.ScanSondages(rows)
}