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

package acvegestion

import (
	"bytes"
	"encoding/json"
	"fmt"
	"mime"
	"strconv"
	"time"

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

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

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

	"github.com/labstack/echo"
)

// GetUsers renvoie la liste des utilisateurs du client
func (ct Controller) GetUsers(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	users, err := rd.SelectAllUsers(ct.DB)
	if err != nil {
		return err
	}
	var out []rd.ClientUser
	for _, user := range users {
		out = append(out, rd.ClientUser{Id: user.Id, Label: user.Label.String(), IsAdmin: bool(user.IsAdmin)})
	}
	return c.JSON(200, out)
}

// CheckPassword vérifie le mot de passe de l'utilisateur donné
func (ct Controller) CheckPassword(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	in := new(apiserver.ParamsLoggin)
	if err := c.Bind(in); err != nil {
		return fmt.Errorf("Information de loggin invalides : %s", err)
	}
	user, err := rd.SelectUser(ct.DB, in.Id)
	if err != nil {
		return err
	}
	var out apiserver.OutputLoggin
	if user.Mdp.String() == in.Password {
		out.Valid = true
		out.User = user
	}
	return c.JSON(200, out)
}

// SertDB charge toute la base de donnée et la renvoie
// sous forme compressée
func (ct Controller) SertDB(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	b, err := dm.LoadRemoteBaseLocale(ct.DB)
	if err != nil {
		return err
	}
	buf := new(bytes.Buffer)
	if err = b.MarshalCompress(buf); err != nil {
		return err
	}
	c.Response().Header().Add("Content-Length", strconv.Itoa(len(buf.Bytes())))
	return c.Stream(200, mime.TypeByExtension(".gz"), buf)
}

// SertDBHash charge toute la base de donnée et calcule un hash
// compact, renvoyée encodée (multipart).
// Voir SertDBPartiel pour la seconde partie du procédé.
func (ct Controller) SertDBHash(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	b, err := dm.LoadRemoteBaseLocale(ct.DB)
	if err != nil {
		return err
	}
	hash, err := b.Hash()
	if err != nil {
		return shared.FormatErr("Impossible de calculer le hash.", err)
	}
	header, bin, err := hash.Compress()
	if err != nil {
		return shared.FormatErr("Impossible de compresser le hash.", err)
	}
	w := c.Response()
	err = shared.WriteMultipart(w.Header(), w, map[string][]byte{
		apiserver.DBHashHeaderJSONKey: header,
		apiserver.DBHashBinaryKey:     bin,
	})

	return err
}

func (ct Controller) SertDBPartiel(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	var items map[string][]int64
	if err := c.Bind(&items); err != nil {
		return err
	}
	b, err := dm.LoadRemoteBaseLocalePartiel(ct.DB, items)
	if err != nil {
		return err
	}
	buf := new(bytes.Buffer)
	if err = b.MarshalCompress(buf); err != nil {
		return err
	}
	c.Response().Header().Add("Content-Length", strconv.Itoa(len(buf.Bytes())))
	return c.Stream(200, mime.TypeByExtension(".gz"), buf)
}

//--------------------------------------------------------------------
//------------------------ Dons --------------------------------------
//--------------------------------------------------------------------

// GenereRecuFiscal génère une archive contenant les reçus fiscaux,
// et renvoie aussi les dons mis à jour.
func (ct Controller) GenereRecuFiscal(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	in := new(dm.OptionsRecuFiscal)
	if err := c.Bind(in); err != nil {
		return fmt.Errorf("Paramètres de reçus fiscaux invalides : %s", err)
	}

	dons, archive, err := recufiscal.GenereRecuFiscaux(ct.DB, *in)
	if err != nil {
		return err
	}

	donsJson, err := json.Marshal(dons)
	if err != nil {
		return err
	}

	w := c.Response()
	err = shared.WriteMultipart(w.Header(), w, map[string][]byte{
		apiserver.RecusFiscauxJSONKey: donsJson,
		apiserver.RecusFiscauxZIPKey:  archive.Bytes(),
	})
	return err
}

// ImportDonsHelloasso charge et renvoie les dons HelloAsso qui
// n'ont pas encore été importé.
func (ct Controller) ImportDonsHelloasso(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	out, err := ct.importDonsHelloasso()
	if err != nil {
		return shared.FormatErr("Impossible de charger les dons HelloAsso", err)
	}
	return c.JSON(200, out)
}

// IdentifieDonHelloasso crée un nouveau don à partir
// des infos HelloAsso et d'un donateur identifié.
func (ct Controller) IdentifieDonHelloasso(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	var params apiserver.IdentifieDonIn
	if err := c.Bind(&params); err != nil {
		return shared.FormatErr("Paramètres invalides", err)
	}
	out, err := ct.identifieDon(params)
	if err != nil {
		return shared.FormatErr("Impossible d'identifier le don", err)
	}
	return c.JSON(200, out)
}

//--------------------------------------------------------------------
//------------------------ Inscriptions ------------------------------
//--------------------------------------------------------------------

// Marque l'inscription comme validée, après s'être assuré
// qu'aucune personne impliquée n'est temporaire.
// De plus, un mail de dé-verrouillage de la fiche sanitaire
// est envoyé si nécessaire.
// Renvoie la facture mise à jour.
func (ct Controller) ValideInscription(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}

	id, err := shared.ParseId(c, "id")
	if err != nil {
		return err
	}
	rows, err := ct.DB.Query(`SELECT personnes.* FROM personnes 
		JOIN factures ON factures.id_personne = personnes.id
		WHERE factures.id = $1
		UNION
		SELECT personnes.* FROM personnes
		JOIN participants ON participants.id_personne = personnes.id
		WHERE participants.id_facture = $1`, id)
	if err != nil {
		return err
	}
	personnes, err := rd.ScanPersonnes(rows)
	if err != nil {
		return err
	}

	// on s'assure qu'aucune personne n'est temporaire
	for _, personne := range personnes {
		if personne.IsTemporaire {
			return fmt.Errorf("%s n'a pas encore été identifié(e) !", personne.NomPrenom())
		}
	}

	// on propose le partage des fiches sanitaires
	err = ct.checkNotifiePartageFicheSanitaire(c.Request().Host, id)
	if err != nil {
		return err
	}

	row := ct.DB.QueryRow("UPDATE factures SET is_validated = true WHERE id = $1 RETURNING *", id)
	out, err := rd.ScanFacture(row)
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}

// DeleteInscription supprime
func (ct Controller) DeleteInscription(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	id, err := shared.ParseId(c, "id")
	if err != nil {
		return fmt.Errorf("Id (Inscription) invalide : %s", err)
	}
	out, err := ct.deleteInscription(id)
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}

//-----------------------------------------------------------------------
//------------------------ Rapprochements -------------------------------
//-----------------------------------------------------------------------

// IdentifieEquipier identifie un équipier temporaire
func (ct Controller) IdentifieEquipier(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	in := new(apiserver.IdentifieEquipierIn)
	if err := c.Bind(in); err != nil {
		return fmt.Errorf("Paramètres d'identification invalides : %s", err)
	}
	out, err := ct.identifieEquipier(*in)
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}

// IdentifieParticipant identifie un participant temporaire
func (ct Controller) IdentifieParticipant(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	in := new(apiserver.IdentifieParticipantIn)
	if err := c.Bind(in); err != nil {
		return fmt.Errorf("Paramètres d'identification invalides : %s", err)
	}
	out, err := ct.identifieParticipant(*in)
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}

// IdentifieResponsable identifie un responsable temporaire
func (ct Controller) IdentifieResponsable(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	in := new(apiserver.IdentifieResponsableIn)
	if err := c.Bind(in); err != nil {
		return fmt.Errorf("Paramètres d'identification invalides : %s", err)
	}
	out, err := ct.identifieResponsable(*in)
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}

// IdentifieParticipantsimple identifie un participant simple temporaire
// et envoie un message de confirmation.
func (ct Controller) IdentifieParticipantsimple(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	in := new(apiserver.IdentifieParticipantsimpleIn)
	if err := c.Bind(in); err != nil {
		return fmt.Errorf("Paramètres d'identification invalides : %s", err)
	}
	out, err := ct.identifieParticipantsimple(*in)
	if err != nil {
		return err
	}
	err = ct.notifieInscriptionSimpleValide(out.Participantsimple)
	if err != nil {
		return fmt.Errorf("Le participant a bien été identifié, mais l'envoi d'un mail de confirmation a échoué : %s",
			err)
	}
	return c.JSON(200, out)
}

//--------------------------------------------------------------------
//------------------------ Paiements ---------------------------------
//--------------------------------------------------------------------

// MarquePaiementsBordereau
func (ct Controller) MarquePaiementsBordereau(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	var in rd.Ids
	if err := c.Bind(&in); err != nil {
		return fmt.Errorf("Paramètres d'identification invalides : %s", err)
	}
	rows, err := ct.DB.Query("UPDATE paiements SET in_bordereau = $1 WHERE id = ANY($2) RETURNING *", time.Now(), in.AsSQL())
	if err != nil {
		return err
	}
	out, err := rd.ScanPaiements(rows)
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}

//--------------------------------------------------------------------
//------------------------ Documents ---------------------------------
//--------------------------------------------------------------------

// GetDocumentsMiniatures renvoies les miniatures des documents demandés
func (ct Controller) GetDocumentsMiniatures(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	var in rd.Ids
	if err := c.Bind(&in); err != nil {
		return fmt.Errorf("Ids (documents) invalides : %s", err)
	}
	rows, err := ct.DB.Query("SELECT id_document, null, miniature FROM contenu_documents WHERE id_document = ANY ($1)", in.AsSQL())
	if err != nil {
		return err
	}
	out, err := rd.ScanContenuDocuments(rows)
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}

// DownloadDocument renvoie le document décompressé demandé
func (ct Controller) DownloadDocument(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	id, err := shared.ParseId(c, "id")
	if err != nil {
		return err
	}
	contenu, found, err := rd.SelectContenuDocumentByIdDocument(ct.DB, id)
	if err != nil {
		return err
	}
	if !found {
		return fmt.Errorf("Le document (id %d) n'a pas de contenu. Veuillez le supprimer.", id)
	}
	b := contenu.Contenu
	c.Response().Header().Add("Content-length", strconv.Itoa(len(b)))
	return c.Stream(200, "", bytes.NewReader(b))
}

// CreateDocument créé les meta-données et associe le document à
// une cible (personne ou aide)
func (ct Controller) CreateDocument(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	var in apiserver.CreateDocumentIn
	fileName, fileContent, err := documents.ReceiveUploadWithMeta(c, apiserver.DOCUMENT_MAX_SIZE, &in)
	if err != nil {
		return fmt.Errorf("Paramètres invalides : %s", err)
	}
	var out apiserver.CreateDocumentIn
	tx, err := ct.DB.Begin()
	if err != nil {
		return err
	}
	out.Document, err = in.Document.Insert(tx)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	switch target := in.Target.(type) {
	case rd.DocumentPersonne:
		target.IdDocument = out.Document.Id
		out.Target = target
		err = rd.InsertManyDocumentPersonnes(tx, target)
	case rd.DocumentAide:
		target.IdDocument = out.Document.Id
		out.Target = target
		err = rd.InsertManyDocumentAides(tx, target)
	}
	if err != nil {
		return shared.Rollback(tx, err)
	}

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

	err = tx.Commit()
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}

// UploadDocument met à jour le contenu du document
func (ct Controller) UploadDocument(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	id, err := shared.ParseId(c, "id")
	if err != nil {
		return fmt.Errorf("Paramètres d'upload invalides : %s", err)
	}
	fileHeader, err := c.FormFile("file")
	if err != nil {
		return fmt.Errorf("Fichier manquant : %s", err)
	}
	filename, content, err := documents.ReceiveUpload(fileHeader, apiserver.DOCUMENT_MAX_SIZE)
	if err != nil {
		return err
	}

	tx, err := ct.DB.Begin()
	if err != nil {
		return err
	}
	doc, err := documents.SaveDocument(tx, id, content, filename, true)
	if err != nil {
		return shared.Rollback(tx, err)
	}

	if err = tx.Commit(); err != nil {
		return err
	}
	return c.JSON(200, doc)
}

//--------------------------------------------------------------------
//------------------------- Messages ---------------------------------
//--------------------------------------------------------------------

// NotifieMessage ajoute le message donné et envoie un mail de notification
func (ct Controller) NotifieMessage(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	var in apiserver.NotifieMessageIn
	if err := c.Bind(&in); err != nil {
		return err
	}
	out, err := ct.creeMessageCentre(c.Request().Host, in.IdFacture, in.Contenu)
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}

// EditMessage modifie le contenu, sans envoi de mail
func (ct Controller) EditMessage(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	var in apiserver.EditMessageIn
	if err := c.Bind(&in); err != nil {
		return err
	}
	out, err := ct.editMessageCentre(in)
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}

// CreateMessageMessage ajoute un message personnalisé, sans
// notification.
func (ct Controller) CreateMessageMessage(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	var in apiserver.CreateMessageMessage
	if err := c.Bind(&in); err != nil {
		return err
	}
	out, err := ct.createMessageMessage(in)
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}

// NotifieSimple envoie un message sans contenu additionnel
func (ct Controller) NotifieSimple(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	var in apiserver.NotifieSimple
	if err := c.Bind(&in); err != nil {
		return err
	}
	out, err := ct.notifieSimple(c.Request().Host, in)
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}

// NotifiePlaceLiberee modifie le participant et
// envoie un message
func (ct Controller) NotifiePlaceLiberee(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	var in apiserver.NotifiePlaceLibereeIn
	if err := c.Bind(&in); err != nil {
		return err
	}
	out, err := ct.notifiePlaceLiberee(c.Request().Host, in)
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}

// NotifieAttestation envoie un message contenant une attestation
func (ct Controller) NotifieAttestation(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	var in apiserver.NotifieAttestationIn
	if err := c.Bind(&in); err != nil {
		return err
	}
	out, err := ct.notifieAttestation(c.Request().Host, in)
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}

// NotifieDocuments stream l'envoi des documents
func (ct Controller) NotifieDocuments(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	var in apiserver.NotifieDocumentsIn
	if err := c.Bind(&in); err != nil {
		return err
	}
	if err := ct.checkVerrouDocuments(in.IdCamp); err != nil {
		return err
	}
	s := streamDocument{idCamp: in.IdCamp}
	if err := s.checkListeAttente(in.IdsFactures, ct.DB); err != nil {
		return err
	}
	message := rd.Message{Kind: rd.MDocuments}
	err := ct.notifieManyMessages(c.Request().Host, s, message, in.IdsFactures, c.Response())
	return err
}

// NotifieSondages stream l'envoi des sondages
func (ct Controller) NotifieSondages(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	var in apiserver.NotifieDocumentsIn
	if err := c.Bind(&in); err != nil {
		return err
	}

	message := rd.Message{Kind: rd.MSondage}
	err := ct.notifieManyMessages(c.Request().Host, streamSondage{idCamp: in.IdCamp}, message, in.IdsFactures, c.Response())
	return err
}

// NotifieMany stream l'envoi d'un message à plusieurs dossiers
func (ct Controller) NotifieMany(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	var in apiserver.NotifieManyIn
	if err := c.Bind(&in); err != nil {
		return err
	}

	if in.Contenu.TrimSpace() == "" {
		return fmt.Errorf("Message vide !")
	}

	message := rd.Message{Kind: rd.MCentre}
	err := ct.notifieManyMessages(c.Request().Host, streamMessage{contenu: in.Contenu}, message, in.IdsFactures, c.Response())
	return err
}

// LoadInscriptions renvoie les inscriptions brutes, telles
// qu'effectuées sur le formulaire publique, sous forme d'un dictionnaire
func (ct Controller) LoadInscriptions(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	out, err := rd.SelectAllInscriptions(ct.DB)
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}

// FusionneFactures redirige les participants, paiements, messages et
// sondages d'un dossier vers un autre, avant de supprimer le dossier
// maintenant vide. Un mail de notification peut être envoyé.
func (ct Controller) FusionneFactures(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	var params apiserver.FusionneFacturesIn
	if err := c.Bind(&params); err != nil {
		return shared.FormatErr("Paramètres invalides", err)
	}
	out, err := ct.fusionneFactures(c.Request().Host, params)
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}