github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/server/espaceperso/views.go

package espaceperso

import (
	"errors"
	"strconv"
	"strings"
	"time"

	"github.com/benoitkugler/goACVE/server/core/apiserver"
	dm "github.com/benoitkugler/goACVE/server/core/datamodel"

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

	rd "github.com/benoitkugler/goACVE/server/core/rawdata"

	"github.com/labstack/echo"
)

type etatFinancier struct {
	TotalSejours   rd.Euros `json:"total_sejours"`
	TotalAides     rd.Euros `json:"total_aides"`
	TotalPaiements rd.Euros `json:"total_paiements"`
	TotalRestant   rd.Euros `json:"total_restant"`
}

// Accueil renvoie l'appli statique
func Accueil(c echo.Context) error {
	return c.File("server/static/bv/espace_perso.html")
}

// GetMeta charge les données statiques à l'espace perso.
func (ct Controller) GetMetas(c echo.Context) error {
	_, err := ct.decrypteKey(c.Param("key"))
	if err != nil {
		return err
	}
	p, err := ct.getMeta(c.Request().Host)
	if err != nil {
		return err
	}
	return c.JSON(200, p)
}

// GetData charge les données nécessaire à l'espace perso.
func (ct Controller) GetData(c echo.Context) error {
	idFacture, err := ct.decrypteKey(c.Param("key"))
	if err != nil {
		return err
	}
	base, err := ct.loadData(idFacture)
	if err != nil {
		return shared.FormatErr("Le chargement des données (depuis la base) a échoué. Veuillez nous excuser pour ce désagrément.", err)
	}
	p, err := ct.compileData(c.Request().Host, idFacture, base)
	if err != nil {
		return err
	}
	return c.JSON(200, p)
}

// GetFinances charge les données financières à l'espace perso.
func (ct Controller) GetFinances(c echo.Context) error {
	idFacture, err := ct.decrypteKey(c.Param("key"))
	if err != nil {
		return err
	}
	base, err := ct.loadData(idFacture)
	if err != nil {
		return shared.FormatErr("Le chargement des données (depuis la base) a échoué. Veuillez nous excuser pour ce désagrément.", err)
	}
	p, err := ct.loadFinances(c.Request().Host, idFacture, base)
	if err != nil {
		return err
	}
	return c.JSON(200, p)
}

func isFicheSanitaireLocked(mailRespo string, mails []string) bool {
	out := len(mails) > 0
	for _, mail := range mails {
		if strings.TrimSpace(strings.ToLower(mail)) == strings.TrimSpace(strings.ToLower(mailRespo)) {
			out = false
			break
		}
	}
	return out
}

// LoadJoomeo renvoie les données permettant l'accès à Joomeo
func (ct Controller) LoadJoomeo(c echo.Context) error {
	idFacture, err := ct.decrypteKey(c.Param("key"))
	if err != nil {
		return err
	}
	out, err := ct.loadJoomeo(idFacture)
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}

// CreateDocument crée les meta données d'un document
// répondant à la contrainte donnée pour la personne donnée,
// et upload le contenu du fichier
func (ct Controller) CreateDocument(c echo.Context) error {
	if _, err := ct.decrypteKey(c.Param("key")); err != nil {
		return err
	}

	var args InCreateDocument
	fileName, fileContent, err := documents.ReceiveUploadWithMeta(c, apiserver.DOCUMENT_MAX_SIZE, &args)
	if err != nil {
		return shared.FormatErr("Téléversement impossible.", err)
	}
	idPersonne, err := shared.DecodeID(ct.Signing, args.IdPersonne, shared.OrPersonne)
	if err != nil {
		return shared.FormatErr("L'identifiant du participant est invalide.", err)
	}

	idContrainte, err := shared.DecodeID(ct.Signing, args.IdContrainte, shared.OrContrainte)
	if err != nil {
		return shared.FormatErr("L'identifiant de la catégorie de document est invalide.", err)
	}

	doc, err := documents.CreeDocumentPersonne(ct.Signing, ct.DB, c.Request().Host, idPersonne, documents.ParamsNewDocument{
		IdContrainte: idContrainte,
		Description:  rd.String("Ajouté via l'espace personnel"),
		FileContent:  fileContent,
		FileName:     fileName,
	})
	if err != nil {
		return err
	}
	return c.JSON(200, doc)
}

// CreateAide ajoute une aide (non validée) au participant donné,
// et upload un document associé.
func (ct Controller) CreateAide(c echo.Context) error {
	if _, err := ct.decrypteKey(c.Param("key")); err != nil {
		return err
	}
	var inAide ChampsAideEditables
	fileName, fileContent, err := documents.ReceiveUploadWithMeta(c, apiserver.DOCUMENT_MAX_SIZE, &inAide)
	if err != nil {
		return shared.FormatErr("L'aide à ajouter ne semble pas valide.", err)
	}

	idPart, err := shared.DecodeID(ct.Signing, inAide.IdParticipantCrypted, shared.OrParticipant)
	if err != nil {
		return shared.FormatErr("L'identifiant du participant est corrompu.", err)
	}
	idStruct, err := shared.DecodeID(ct.Signing, inAide.IdStructureCrypted, shared.OrStructureaide)
	if err != nil {
		return shared.FormatErr("L'identifiant de la structure est corrompu.", err)
	}
	newAide := rd.Aide{
		IdParticipant:   idPart,
		IdStructureaide: idStruct,
		Valide:          false,
		NbJoursMax:      inAide.NbJoursMax,
		ParJour:         inAide.ParJour,
		Valeur:          inAide.Valeur,
	}
	tx, err := ct.DB.Begin()
	if err != nil {
		return err
	}

	part, err := rd.SelectParticipant(tx, newAide.IdParticipant)
	if err != nil {
		return shared.Rollback(tx, err)
	}

	camp, err := rd.SelectCamp(tx, part.IdCamp)
	if err != nil {
		return shared.Rollback(tx, err)
	}

	newAide, err = newAide.Insert(tx)
	if err != nil {
		return shared.Rollback(tx, err)
	}

	newDoc := rd.Document{
		Description:    "Créé via l'espace personnel",
		DateHeureModif: rd.Time(time.Now()),
	}
	newDoc, err = newDoc.Insert(tx)
	if err != nil {
		return shared.Rollback(tx, err)
	}

	link := rd.DocumentAide{
		IdAide:     newAide.Id,
		IdDocument: newDoc.Id,
	}
	err = rd.InsertManyDocumentAides(tx, link)
	if err != nil {
		return shared.Rollback(tx, err)
	}

	newDoc, err = documents.SaveDocument(tx, newDoc.Id, fileContent, fileName, true)
	if err != nil {
		return shared.Rollback(tx, err)
	}

	base := dm.BaseLocale{
		Camps:        rd.Camps{camp.Id: camp},
		Participants: rd.Participants{part.Id: part},
		Aides:        rd.Aides{newAide.Id: newAide},
		Documents:    rd.Documents{newDoc.Id: newDoc},
	}
	base.DocumentAides = map[int64]rd.DocumentAide{newDoc.Id: link}

	outAide, err := ct.shareAide(c.Request().Host, base.NewAide(newAide.Id))
	if err != nil {
		return shared.Rollback(tx, err)
	}

	// le participant et la structure ont été choisit par le client
	outAide.IdParticipantCrypted = inAide.IdParticipantCrypted
	outAide.IdStructureCrypted = inAide.IdStructureCrypted

	if err = tx.Commit(); err != nil {
		return shared.FormatErr("La validation de l'ajout du document a échoué.", err)
	}
	return c.JSON(200, outAide)
}

// UpdateAide met à jour une aide encore non validée.
func (ct Controller) UpdateAide(c echo.Context) error {
	if _, err := ct.decrypteKey(c.Param("key")); err != nil {
		return err
	}
	var inAide Aide
	if err := c.Bind(&inAide); err != nil {
		return shared.FormatErr("L'aide à ajouter ne semble pas valide.", err)
	}
	idAide, err := shared.DecodeID(ct.Signing, inAide.IdCrypted, shared.OrAide)
	if err != nil {
		return shared.FormatErr("L'identifiant de l'aide est corrompu.", err)
	}
	tx, err := ct.DB.Begin()
	if err != nil {
		return err
	}

	aide, err := rd.SelectAide(tx, idAide)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	if aide.Valide {
		_ = tx.Rollback()
		return errors.New("Cette aide a déjà été validée: les modifications sont désactivées.")
	}

	idPart, err := shared.DecodeID(ct.Signing, inAide.IdParticipantCrypted, shared.OrParticipant)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	idStruct, err := shared.DecodeID(ct.Signing, inAide.IdStructureCrypted, shared.OrStructureaide)
	if err != nil {
		return shared.Rollback(tx, err)
	}

	aide.NbJoursMax = inAide.NbJoursMax
	aide.Valeur = inAide.Valeur
	aide.ParJour = inAide.ParJour
	aide.IdParticipant = idPart
	aide.IdStructureaide = idStruct
	aide, err = aide.Update(tx)
	if err != nil {
		return shared.Rollback(tx, err)
	}

	part, err := rd.SelectParticipant(tx, aide.IdParticipant)
	if err != nil {
		return shared.Rollback(tx, err)
	}

	camp, err := rd.SelectCamp(tx, part.IdCamp)
	if err != nil {
		return shared.Rollback(tx, err)
	}

	base := dm.BaseLocale{
		Camps:        rd.Camps{camp.Id: camp},
		Participants: rd.Participants{part.Id: part},
		Aides:        rd.Aides{aide.Id: aide},
	}

	outAide, err := ct.shareAide(c.Request().Host, base.NewAide(aide.Id))
	if err != nil {
		return shared.Rollback(tx, err)
	}
	// on ne modifie pas les champs suivants
	outAide.IdCrypted = inAide.IdCrypted
	outAide.IdParticipantCrypted = inAide.IdParticipantCrypted
	outAide.IdStructureCrypted = inAide.IdStructureCrypted
	outAide.Document = inAide.Document
	if err = tx.Commit(); err != nil {
		return shared.FormatErr("La modification de l'aide a échoué.", err)
	}
	return c.JSON(200, outAide)
}

// DeleteAide supprime l'aide non validée et le document associé
func (ct Controller) DeleteAide(c echo.Context) error {
	if _, err := ct.decrypteKey(c.Param("key")); err != nil {
		return err
	}
	id, err := shared.DecodeID(ct.Signing, c.QueryParam("id-crypted"), shared.OrAide)
	if err != nil {
		return shared.FormatErr("L'aide n'a pu être identifiée.", err)
	}

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

	aide, err := rd.SelectAide(tx, id)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	if aide.Valide {
		_ = tx.Rollback()
		return errors.New("Cette aide a déjà été validée: les modifications sont désactivées.")
	}

	// suppression du lien
	row := tx.QueryRow("DELETE FROM document_aides WHERE id_aide = $1 RETURNING *", id)
	documentAide, err := rd.ScanDocumentAide(row)
	if err != nil {
		return shared.Rollback(tx, err)
	}

	// suppression du contenu par cascade

	// suppression du document
	_, err = rd.DeleteDocumentById(tx, documentAide.IdDocument)
	if err != nil {
		return shared.Rollback(tx, err)
	}

	// finalement, suppression de l'aide
	if _, err = rd.DeleteAideById(tx, aide.Id); err != nil {
		return shared.Rollback(tx, err)
	}
	if err = tx.Commit(); err != nil {
		return shared.FormatErr("La suppression de l'aide a échoué.", err)
	}
	return c.NoContent(200)
}

// UpdateFicheSanitaire met à jour une fiche sanitaire
func (ct Controller) UpdateFicheSanitaire(c echo.Context) error {
	idFacture, err := ct.decrypteKey(c.Param("key"))
	if err != nil {
		return err
	}
	var params InFicheSanitaire
	if err = c.Bind(&params); err != nil {
		return shared.FormatErr("La fiche sanitaire est corrompue", err)
	}

	out, err := ct.updateFicheSanitaire(idFacture, params)
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}

// TransfertFicheSanitaire envoie un mail de demande de transfert
func (ct Controller) TransfertFicheSanitaire(c echo.Context) error {
	idFacture, err := ct.decrypteKey(c.Param("key"))
	if err != nil {
		return err
	}
	idCrypted := c.QueryParam("id-crypted")
	respo, pers, err := ct.loadDataFicheSanitaire(idFacture, idCrypted)
	if err != nil {
		return err
	}
	mailErrors, err := ct.SendMailPartageFicheSanitaire(c.Request().Host, respo.Mail.String(), pers)
	if err != nil {
		return err
	}
	return c.JSON(200, mailErrors)
}

// ValideTransfertFicheSanitaire accepte un transfert.
func (ct Controller) ValideTransfertFicheSanitaire(c echo.Context) error {
	target := c.QueryParam("target")
	if err := ct.validePartageFicheSanitaire(target); err != nil {
		return shared.RedirectError(c, err)
	}
	return shared.RedirectSuccess(c, "Partage de fiche sanitaire", "Fiche sanitaire partagée",
		"L'accès à la fiche a bien été mis à jour. <br/>"+
			"<small class='text-muted'>Vous pouvez actualiser votre espace de suivi pour y accéder.</small>")
}

// UpdateOptionsParticipants met à jour les participants
func (ct Controller) UpdateOptionsParticipants(c echo.Context) error {
	if _, err := ct.decrypteKey(c.Param("key")); err != nil {
		return err
	}
	var args struct {
		Participants []Participant `json:"participants"`
	}
	if err := c.Bind(&args); err != nil {
		return shared.FormatErr("Les options n'ont pas pu être lues.", err)
	}
	if err := ct.updateOptionsParticipants(args.Participants); err != nil {
		return err
	}
	return c.NoContent(200)
}

// DownloadFacture gènère le document et met à jour les messages
// (les données devraient être raffraichies)
func (ct Controller) DownloadFacture(c echo.Context) error {
	idFacture, err := ct.decrypteKey(c.Param("key"))
	if err != nil {
		return err
	}
	s := c.QueryParam("index-destinataire")
	indexDestinataire, _ := strconv.Atoi(s) // fallback to responsable
	out, name, err := ct.downloadFacture(idFacture, indexDestinataire)
	if err != nil {
		return shared.RedirectError(c, err)
	}
	return documents.Attachment(c, name, out, true)
}

// DownloadAttestationPresence gènère le document et met à jour les messages
// (les données devraient être raffraichies)
func (ct Controller) DownloadAttestationPresence(c echo.Context) error {
	idFacture, err := ct.decrypteKey(c.Param("key"))
	if err != nil {
		return err
	}
	s := c.QueryParam("index-destinataire")
	indexDestinataire, _ := strconv.Atoi(s) // fallback to responsable
	out, err := ct.downloadAttestationPresence(idFacture, indexDestinataire)
	if err != nil {
		return shared.RedirectError(c, err)
	}
	return documents.Attachment(c, "Attestation.pdf", out, true)
}

// MarkConnection enregistre la connection sur l'espace de suivi,
// pour permettre la mise à jour de l'état des notifications.
func (ct Controller) MarkConnection(c echo.Context) error {
	idFacture, err := ct.decrypteKey(c.Param("key"))
	if err != nil {
		return err
	}
	err = ct.markConnection(idFacture)
	if err != nil {
		return err
	}
	return c.NoContent(200)
}

// SaveSondage enregiste le retour sur un séjour.
// Un idCrypted vide crée un nouvel item
func (ct Controller) SaveSondage(c echo.Context) error {
	idFacture, err := ct.decrypteKey(c.Param("key"))
	if err != nil {
		return err
	}
	var params PublicSondage
	if err = c.Bind(&params); err != nil {
		return err
	}
	out, err := ct.saveSondage(c.Request().Host, idFacture, params)
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}

// CreeMessage envoie un nouveau message.
func (ct Controller) CreeMessage(c echo.Context) error {
	idFacture, err := ct.decrypteKey(c.Param("key"))
	if err != nil {
		return err
	}
	var params EditMessage
	if err = c.Bind(&params); err != nil {
		return err
	}
	out, err := ct.creeMessage(idFacture, params.Contenu)
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}

// EditMessage modifie le contenu d'un message existant.
func (ct Controller) EditMessage(c echo.Context) error {
	idFacture, err := ct.decrypteKey(c.Param("key"))
	if err != nil {
		return err
	}
	var params EditMessage
	if err = c.Bind(&params); err != nil {
		return err
	}
	out, err := ct.editMessage(idFacture, params)
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}

// DeleteMessage supprime un message libre.
// Le message est marqué comme supprimé, et son contenu est réellement supprimé.
func (ct Controller) DeleteMessage(c echo.Context) error {
	idFacture, err := ct.decrypteKey(c.Param("key"))
	if err != nil {
		return err
	}
	idMessage, err := shared.ParseId(c, "id-message")
	if err != nil {
		return err
	}
	out, err := ct.deleteMessage(idFacture, idMessage)
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}

// ConfirmePlaceliberee passe le participant en liste principale
// et recharge les données.
func (ct Controller) ConfirmePlaceliberee(c echo.Context) error {
	idFacture, err := ct.decrypteKey(c.Param("key"))
	if err != nil {
		return err
	}
	idMessage, err := shared.ParseId(c, "id-message")
	if err != nil {
		return err
	}
	err = ct.confirmePlaceliberee(idFacture, idMessage)
	if err != nil {
		return err
	}
	// les participants ont changés
	base, err := ct.loadData(idFacture)
	if err != nil {
		return shared.FormatErr("Le chargement des données (depuis la base) a échoué. Veuillez nous excuser pour ce désagrément.", err)
	}
	p, err := ct.compileData(c.Request().Host, idFacture, base)
	if err != nil {
		return err
	}
	return c.JSON(200, p)
}