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

package acvegestion

import (
	"database/sql"
	"errors"
	"fmt"
	"time"

	"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/benoitkugler/goACVE/server/shared"
	"github.com/labstack/echo"
)

const notifDonReplyTo = "contact@acve.asso.fr"

// ajoute les actions spécifiques au CRUD

func (ct Controller) deleteAide(idAide int64) (rd.Ids, error) {
	tx, err := ct.DB.Begin()
	if err != nil {
		return nil, err
	}

	// liens
	rows, err := tx.Query("DELETE FROM document_aides WHERE id_aide = $1 RETURNING id_document", idAide)
	if err != nil {
		return nil, shared.Rollback(tx, err)
	}
	deletedDocuments, err := rd.ScanIds(rows)
	if err != nil {
		return nil, shared.Rollback(tx, err)
	}

	//documents
	_, err = rd.DeleteDocumentsByIds(tx, deletedDocuments...)
	if err != nil {
		return nil, shared.Rollback(tx, err)
	}

	_, err = rd.DeleteAideById(tx, idAide)
	if err != nil {
		return nil, shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return deletedDocuments, err
}

func (ct Controller) createCamp(params apiserver.CreateCampIn) (rd.Camp, error) {
	tx, err := ct.DB.Begin()
	if err != nil {
		return rd.Camp{}, err
	}
	camp, err := params.Camp.Insert(tx)
	if err != nil {
		return camp, shared.Rollback(tx, err)
	}

	// on importe le html de la lettre directeur
	if idCamp := params.CopyLettreFrom; idCamp.IsNotNil() {
		lettre, found, err := rd.SelectLettredirecteurByIdCamp(tx, idCamp.Int64)
		if err != nil {
			return camp, shared.Rollback(tx, err)
		}
		if found {
			lettre.IdCamp = camp.Id
			err = rd.InsertManyLettredirecteurs(tx, lettre)
			if err != nil {
				return camp, shared.Rollback(tx, err)
			}
		} // sinon, le camp source n'a pas de lettre, on ne fait rien

		// copie des potentielles images associées
		// le lien d'accès n'est pas changé ce qui évite de devoir modifier
		// le contenu de la lettre
		imgs, err := rd.SelectImageuploadedsByIdCamps(tx, idCamp.Int64)
		if err != nil {
			return camp, shared.Rollback(tx, err)
		}
		for i := range imgs {
			imgs[i].IdCamp = camp.Id // on redirige vers le nouveau camp
		}
		err = rd.InsertManyImageuploadeds(tx, imgs...)
		if err != nil {
			return camp, shared.Rollback(tx, err)
		}

		// les tables lettre et images sont ignorées par le client :
		// on en renvoit rien
	}
	err = tx.Commit()
	return camp, err
}

// CreateCamp ajoute un camp
func (ct Controller) CreateCamp(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	var in apiserver.CreateCampIn
	if err := c.Bind(&in); err != nil {
		return fmt.Errorf("Camp invalide : %s", err)
	}
	out, err := ct.createCamp(in)
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}

// UpdateCamp met à jour et renvoie le camp modifié; le statut simple
// ne peut pas être modifié.
func (ct Controller) UpdateCamp(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	in := new(rd.Camp)
	if err := c.Bind(in); err != nil {
		return fmt.Errorf("Camp invalide : %s", err)
	}
	trueCamp, err := rd.SelectCamp(ct.DB, in.Id)
	if err != nil {
		return err
	}
	if trueCamp.InscriptionSimple != in.InscriptionSimple {
		return errors.New("Le mode d'inscription ne peut pas être modifié.")
	}
	updated, err := in.Update(ct.DB)
	if err != nil {
		return err
	}
	return c.JSON(200, updated)
}

// renvoie une erreur si un équipier ou un participant est encore inscrit
// en revanche, cascade la suppression des groupes et documents du séjour
func (ct Controller) deleteCamp(idCamp int64) (apiserver.DeleteCampOut, error) {
	var out apiserver.DeleteCampOut
	tx, err := ct.DB.Begin()
	if err != nil {
		return out, err
	}

	// liens documents
	rows, err := tx.Query("DELETE FROM document_camps WHERE id_camp = $1 RETURNING id_document", idCamp)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	out.IdsDocuments, err = rd.ScanIds(rows)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}

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

	// contraintes demandées
	_, err = rd.DeleteCampContraintesByIdCamps(tx, idCamp)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}

	// liens groupes
	_, err = tx.Exec(`DELETE FROM groupe_contraintes 
		USING groupes WHERE groupes.id_camp = $1 AND 
		groupe_contraintes.id_groupe = groupes.id`, idCamp)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}

	// groupes
	out.IdsGroupes, err = rd.DeleteGroupesByIdCamps(tx, idCamp)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}

	_, err = rd.DeleteCampById(tx, idCamp)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return out, err
}

// DeleteCamp supprime
func (ct Controller) DeleteCamp(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 (Camp) invalide : %s", err)
	}
	out, err := ct.deleteCamp(id)
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}

// charger les données et trouve un groupe pour le nouveau participant
// ne commit ni ne rollback
func (ct Controller) findGroupe(tx *sql.Tx, participant rd.Participant) (rd.GroupeParticipant, bool, error) {
	personne, err := rd.SelectPersonne(tx, participant.IdPersonne)
	if err != nil {
		return rd.GroupeParticipant{}, false, err
	}
	// charge le camp et les groupes
	camp, err := rd.SelectCamp(tx, participant.IdCamp)
	if err != nil {
		return rd.GroupeParticipant{}, false, err
	}

	groupes, err := rd.SelectGroupesByIdCamps(tx, camp.Id)
	if err != nil {
		return rd.GroupeParticipant{}, false, err
	}
	var gp rd.GroupeParticipant
	groupe, foundGroupe := composites.NewCampGroupes(camp, groupes).TrouveGroupe(personne.DateNaissance)
	if foundGroupe { // on ajoute
		gp = rd.GroupeParticipant{IdCamp: camp.Id, IdGroupe: groupe.Id, IdParticipant: participant.Id}
		err = rd.InsertManyGroupeParticipants(tx, gp)
		if err != nil {
			return rd.GroupeParticipant{}, false, err
		}
	}
	return gp, foundGroupe, nil
}

// CreateParticipant ajoute et renvoie, avec un éventuel groupe
func (ct Controller) CreateParticipant(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	in := new(rd.Participant)
	if err := c.Bind(in); err != nil {
		return fmt.Errorf("Participant invalide : %s", err)
	}
	tx, err := ct.DB.Begin()
	if err != nil {
		return err
	}
	var out apiserver.CreateParticipantOut
	out.Participant, err = in.Insert(tx)
	if err != nil {
		return shared.Rollback(tx, err)
	}

	out.GroupeParticipant, out.FoundGroupe, err = ct.findGroupe(tx, out.Participant)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	if err = tx.Commit(); err != nil {
		return err
	}
	return c.JSON(200, out)
}

// UpdateParticipant met à jour le groupe si le camp change
func (ct Controller) UpdateParticipant(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	in := new(rd.Participant)
	if err := c.Bind(in); err != nil {
		return fmt.Errorf("Participant invalide : %s", err)
	}
	tx, err := ct.DB.Begin()
	if err != nil {
		return err
	}
	currentParticipant, err := rd.SelectParticipant(tx, in.Id)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	isChangingCamp := in.IdCamp != currentParticipant.IdCamp
	if isChangingCamp {
		// on doit transférer un éventuel groupe
		_, err := rd.DeleteGroupeParticipantsByIdParticipants(tx, in.Id)
		if err != nil {
			return shared.Rollback(tx, err)
		}
	}
	var out apiserver.CreateParticipantOut
	out.Participant, err = in.Update(tx)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	if isChangingCamp {
		// on affecte à un nouveau groupe
		out.GroupeParticipant, out.FoundGroupe, err = ct.findGroupe(tx, out.Participant)
		if err != nil {
			return shared.Rollback(tx, err)
		}
	}
	if err = tx.Commit(); err != nil {
		return err
	}
	return c.JSON(200, out)
}

// CreateFacture génère une clé unique, ratache les participants donnés à la facture
// et renvois la facture et les participants mis à jour.
// Note: Si un participant était déjà dans un dossier, il est simplement redirigé.
func (ct Controller) CreateFacture(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	in := new(apiserver.CreateFactureIn)
	if err := c.Bind(in); err != nil {
		return fmt.Errorf("Facture invalide : %s", err)
	}
	tx, err := ct.DB.Begin()
	if err != nil {
		return err
	}
	key, err := shared.GetNewKey(tx)
	if err != nil {
		err = fmt.Errorf("Création de la clé du dossier impossible : %s", err)
		return shared.Rollback(tx, err)
	}
	// l'inscription est créé par le centre, donc elle est valide
	// le champ IsConfirmed n'a pas vraiment de sens : il faut mieux
	// le cocher pour éviter des avertissements
	// On permet le partage des coordonnées: permissif par défaut
	fac := rd.Facture{IdPersonne: in.IdResponsable, Key: rd.String(key),
		IsValidated: true, IsConfirmed: true, PartageAdressesOK: true}
	fac, err = fac.Insert(tx)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	out := apiserver.CreateFactureOut{Facture: fac}

	rows, err := tx.Query("UPDATE participants SET id_facture = $1 WHERE id = ANY($2) RETURNING *",
		fac.Id, in.IdParticipants.AsSQL())
	if err != nil {
		return shared.Rollback(tx, err)
	}
	out.Participants, err = rd.ScanParticipants(rows)
	if err != nil {
		return shared.Rollback(tx, err)
	}

	// enregistre le moment "d'inscription"
	out.Message = rd.Message{Kind: rd.MInscription, Created: rd.Time(time.Now()), IdFacture: fac.Id}
	out.Message, err = out.Message.Insert(tx)
	if err != nil {
		return shared.Rollback(tx, err)
	}

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

// supprime la facture et les paiements associés,
// et met à jour les participants si besoin
func (ct Controller) deleteFacture(id int64) (apiserver.DeleteFactureOut, error) {
	var out apiserver.DeleteFactureOut
	tx, err := ct.DB.Begin()
	if err != nil {
		return out, err
	}

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

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

	_, err = rd.DeleteFactureById(tx, id)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return out, err
}

// supprime aussi les aides (et leurs justificatifs)
// si le participant est temporaire, supprime aussi la personne associée
func (ct Controller) deleteParticipant(id int64) (apiserver.DeleteParticipantOut, error) {
	tx, err := ct.DB.Begin()
	if err != nil {
		return apiserver.DeleteParticipantOut{}, err
	}
	out, err := deleteOneParticipant(tx, id)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return out, err
}

// supprime aussi les aides associées (et leurs documents)
func (ct Controller) deleteStructureaide(id int64) (apiserver.DeleteStructureaideOut, error) {
	var out apiserver.DeleteStructureaideOut
	tx, err := ct.DB.Begin()
	if err != nil {
		return out, err
	}

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

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

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

	_, err = rd.DeleteStructureaideById(tx, id)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return out, err
}

// si l'équipier est temporaire, supprime aussi la personne associée (et ses documents)
func (ct Controller) deleteEquipier(id int64) (apiserver.DeleteEquipierOut, error) {
	var out apiserver.DeleteEquipierOut

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

	equipier, err := rd.DeleteEquipierById(tx, id)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}

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

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

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

func (ct Controller) deleteDocument(id int64) (rd.Contraintes, error) {
	tx, err := ct.DB.Begin()
	if err != nil {
		return nil, err
	}

	// les liens et le contenu cascadent

	// contrainte
	rows, err := tx.Query("UPDATE contraintes SET id_document = NULL WHERE id_document = $1 RETURNING *", id)
	if err != nil {
		return nil, shared.Rollback(tx, err)
	}
	contraintes, err := rd.ScanContraintes(rows)
	if err != nil {
		return nil, shared.Rollback(tx, err)
	}
	_, err = rd.DeleteDocumentById(tx, id)
	if err != nil {
		return nil, shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return contraintes, err
}

// supprime les liens et marque le message
func (ct Controller) deleteMessages(ids rd.Ids) (rd.Messages, error) {
	// on ne supprime pas vraiment, on change 'kind', donc on doit "manuellement"
	// supprimer les liens
	tx, err := ct.DB.Begin()
	if err != nil {
		return nil, err
	}
	for _, table := range rd.ComplementMessagesTables {
		_, err := tx.Exec(fmt.Sprintf("DELETE FROM %s WHERE id_message = ANY($1)", table), ids.AsSQL())
		if err != nil {
			return nil, shared.Rollback(tx, err)
		}
	}
	rows, err := tx.Query("UPDATE messages SET (kind, modified) = ($1 , $2) WHERE id = ANY($3) RETURNING *",
		rd.MSupprime, rd.Time(time.Now()), ids.AsSQL())
	if err != nil {
		return nil, shared.Rollback(tx, err)
	}
	out, err := rd.ScanMessages(rows)
	if err != nil {
		return nil, shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return out, err
}

// DeleteMessages supprime
func (ct Controller) DeleteMessages(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	var ids rd.Ids
	if err := c.Bind(&ids); err != nil {
		return fmt.Errorf("Ids (Messages) invalides : %s", err)
	}
	out, err := ct.deleteMessages(ids)
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}

// Ajoute l'équipier transmit et ajoute des contraintes par défaut
func (ct Controller) CreateEquipier(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	in := new(rd.Equipier)
	if err := c.Bind(in); err != nil {
		return fmt.Errorf("Equipier invalide : %s", err)
	}
	tx, err := ct.DB.Begin()
	if err != nil {
		return err
	}
	var out apiserver.CreateEquipierOut
	out.Equipier, err = in.Insert(tx)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	out.Contraintes, err = shared.AddEquipierDefautContraintes(tx, ct.ContraintesEquipiers, out.Equipier)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	if err = tx.Commit(); err != nil {
		return err
	}
	return c.JSON(200, out)
}

func (ct Controller) CreateDon(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	var in apiserver.CreateDonIn
	if err := c.Bind(&in); err != nil {
		return fmt.Errorf("Détails du don invalides : %s", err)
	}
	out, err := ct.createDon(in)
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}

// inscrit le don et envoie un mail de remerciement, sauf pour les dons Helloasso
func (ct Controller) createDon(params apiserver.CreateDonIn) (apiserver.CreateDonIn, error) {
	tx, err := ct.DB.Begin()
	if err != nil {
		return params, err
	}
	params.Don, err = params.Don.Insert(tx)
	if err != nil {
		return params, shared.Rollback(tx, err)
	}
	// ajout de l'id nouvellement créé
	params.Donateur.IdDon = params.Don.Id

	// on n'ajoute pas de lien pour les dons anonymes
	if params.Donateur.IId() != nil {
		err = rd.InsertManyDonDonateurs(tx, params.Donateur)
		if err != nil {
			return params, shared.Rollback(tx, err)
		}
	}

	// mail de remerciement
	if params.Notifie && params.Don.ModePaiement != rd.MPHelloasso {

		// on résoud le donateur
		contact, mail := mails.Contact{}, ""
		if p := params.Donateur.IdPersonne; p.IsNotNil() {
			donateur, err := rd.SelectPersonne(tx, p.Int64)
			if err != nil {
				return params, shared.Rollback(tx, err)
			}
			contact = mails.Contact{Prenom: donateur.FPrenom(), Sexe: donateur.Sexe}
			mail = donateur.Mail.String()
		} else if p := params.Donateur.IdOrganisme; p.IsNotNil() {
			orga, err := rd.SelectOrganisme(tx, p.Int64)
			if err != nil {
				return params, shared.Rollback(tx, err)
			}
			if p := orga.IdContactDon; p.IsNotNil() {
				donateur, err := rd.SelectPersonne(tx, p.Int64)
				if err != nil {
					return params, shared.Rollback(tx, err)
				}
				contact = mails.Contact{Prenom: donateur.FPrenom(), Sexe: donateur.Sexe}
				mail = donateur.Mail.String()
			} else if p := orga.IdContact; p.IsNotNil() {
				donateur, err := rd.SelectPersonne(tx, p.Int64)
				if err != nil {
					return params, shared.Rollback(tx, err)
				}
				contact = mails.Contact{Prenom: donateur.FPrenom(), Sexe: donateur.Sexe}
				mail = donateur.Mail.String()
			} else { // adresse propre
				contact = mails.Contact{}
				mail = orga.Contact.Mail.String()
			}
		}

		if mail == "" {
			return params, shared.Rollback(tx, errors.New("Aucune adresse mail."))
		}

		body, err := mails.NewNotificationDon(contact, params.Don.Valeur)
		if err != nil {
			return params, shared.Rollback(tx, err)
		}
		err = mails.NewMailer(ct.SMTP).SendMail(mail, "[ACVE] - Remerciement", body, nil,
			mails.CustomReplyTo(notifDonReplyTo))
		if err != nil {
			return params, shared.Rollback(tx, err)
		}
	}

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

func (ct Controller) UpdateDon(c echo.Context) error {
	if err := authentifie(c); err != nil {
		return err
	}
	var in apiserver.CreateDonIn
	if err := c.Bind(&in); err != nil {
		return fmt.Errorf("Détails du don invalides : %s", err)
	}
	out, err := ct.updateDon(in)
	if err != nil {
		return err
	}
	return c.JSON(200, out)
}

func (ct Controller) updateDon(params apiserver.CreateDonIn) (apiserver.CreateDonIn, error) {
	tx, err := ct.DB.Begin()
	if err != nil {
		return params, err
	}
	params.Don, err = params.Don.Update(tx)
	if err != nil {
		return params, shared.Rollback(tx, err)
	}

	// on assure la cohérence, sait-on jamais ?
	params.Donateur.IdDon = params.Don.Id

	// suppression de l'ancien lien ...
	_, err = rd.DeleteDonDonateursByIdDons(tx, params.Don.Id)
	if err != nil {
		return params, shared.Rollback(tx, err)
	}
	// ... et ajout du nouveau
	// on n'ajoute pas de lien pour les dons anonymes
	if params.Donateur.IId() != nil {
		err = rd.InsertManyDonDonateurs(tx, params.Donateur)
		if err != nil {
			return params, shared.Rollback(tx, err)
		}
	}
	err = tx.Commit()
	return params, err
}

func (ct Controller) deleteOrganisme(id int64) (apiserver.DeleteOrganismeOut, error) {
	out := apiserver.DeleteOrganismeOut{Id: id}
	tx, err := ct.DB.Begin()
	if err != nil {
		return out, err
	}
	liens, err := rd.DeleteDonDonateursByIdOrganismes(tx, id)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	var ids rd.Ids
	for idDon := range liens.ByIdDon() {
		ids = append(ids, idDon)
	}
	out.Dons, err = rd.DeleteDonsByIds(tx, ids...)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	_, err = rd.DeleteOrganismeById(tx, id)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return out, err
}