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

// Implémente le formulaire équipier (informations, document, charte, ...)
package equipier

import (
	"sort"

	rd "github.com/benoitkugler/goACVE/server/core/rawdata"
	"github.com/benoitkugler/goACVE/server/core/utils/joomeo"
	"github.com/benoitkugler/goACVE/logs"
	"github.com/benoitkugler/goACVE/server/documents"
	"github.com/benoitkugler/goACVE/server/shared"
)

type Controller struct {
	shared.Controller

	joomeo logs.Joomeo
}

func NewController(basic shared.Controller, joomeo logs.Joomeo) Controller {
	return Controller{Controller: basic, joomeo: joomeo}
}

// fromPersonneEquipier prend aussi en compte le statut de l'invitation et de la charte
func fromPersonneEquipier(personne rd.Personne, equipier rd.Equipier) EquipierEquipier {
	out := EquipierEquipier{shared.FromPersonneEquipier(personne, equipier)}

	out.InvitationEquipier = equipier.InvitationEquipier
	out.Charte = equipier.Charte

	return out
}

func (eq EquipierEquipier) ToPersonneEquipier(personne *rd.BasePersonne, equipier *rd.Equipier) {
	eq.BaseEquipier.ToPersonneEquipier(personne, equipier)
	equipier.InvitationEquipier = eq.InvitationEquipier
	equipier.Charte = eq.Charte
}

func (ct Controller) identifie(link string) (int64, error) {
	return shared.DecodeID(ct.Signing, link, shared.OrEquipier)
}

func (ct Controller) loadData(host string, idEquipier int64) (datas DataEquipier, err error) {
	equipier, err := rd.SelectEquipier(ct.DB, idEquipier)
	if err != nil {
		return
	}
	eqContraintes, err := rd.SelectEquipierContraintesByIdEquipiers(ct.DB, idEquipier)
	if err != nil {
		return
	}
	rows, err := ct.DB.Query(`SELECT contraintes.* FROM contraintes 
	JOIN equipier_contraintes ON equipier_contraintes.id_contrainte = contraintes.id 
	WHERE equipier_contraintes.id_equipier = $1`, idEquipier)
	if err != nil {
		return
	}
	contraintes, err := rd.ScanContraintes(rows)
	if err != nil {
		return
	}
	personne, err := rd.SelectPersonne(ct.DB, equipier.IdPersonne)
	if err != nil {
		return
	}
	datas.Equipier = fromPersonneEquipier(personne, equipier)

	camp, err := rd.SelectCamp(ct.DB, equipier.IdCamp)
	if err != nil {
		return
	}
	datas.Camp.From(camp)

	docs, err := ct.LoadDocuments(rd.Ids{personne.Id})
	if err != nil {
		return
	}

	// on regroupe les documents présents par contrainte
	byContrainte := make(map[int64][]rd.Document)
	for _, lien := range docs.Liens {
		byContrainte[lien.IdContrainte] = append(byContrainte[lien.IdContrainte], docs.Documents[lien.IdDocument])
	}

	// on publie les documents liés à chaque contraintes
	for _, eqContrainte := range eqContraintes {
		pubContrainte, err := documents.PublieContrainte(ct.Signing, ct.DB, host, contraintes[eqContrainte.IdContrainte])
		if err != nil {
			return datas, err
		}
		cds := documents.ContrainteDocuments{Contrainte: pubContrainte}
		for _, doc := range byContrainte[eqContrainte.IdContrainte] {
			publicDoc, err := documents.PublieDocument(ct.Signing, host, doc)
			if err != nil {
				return datas, err
			}
			cds.Docs = append(cds.Docs, publicDoc)
		}

		datas.Pieces = append(datas.Pieces, ContrainteEquipier{ContrainteDocuments: cds, Optionnel: eqContrainte.Optionnel})
	}
	sort.Slice(datas.Pieces, func(i, j int) bool {
		return datas.Pieces[i].Contrainte.Nom < datas.Pieces[j].Contrainte.Nom
	})
	return
}

func (ct Controller) updateEquipier(eq EquipierEquipier, idEquipier int64) (EquipierEquipier, error) {
	tx, err := ct.DB.Begin()
	if err != nil {
		return eq, err
	}
	eq.InvitationEquipier = rd.Verifie

	equipier, err := rd.SelectEquipier(tx, idEquipier)
	if err != nil {
		return eq, shared.Rollback(tx, err)
	}
	personne, err := rd.SelectPersonne(tx, equipier.IdPersonne)
	if err != nil {
		return eq, shared.Rollback(tx, err)
	}

	eq.ToPersonneEquipier(&personne.BasePersonne, &equipier)

	personne, err = personne.Update(tx)
	if err != nil {
		return eq, shared.Rollback(tx, err)
	}
	equipier, err = equipier.Update(tx)
	if err != nil {
		return eq, shared.Rollback(tx, err)
	}

	return fromPersonneEquipier(personne, equipier), tx.Commit() // mis à jour en retour
}

func (ct Controller) updateCharte(idEquipier int64, charte rd.OptionnalBool) error {
	_, err := ct.DB.Exec("UPDATE equipiers SET charte = $1 WHERE id = $2", charte, idEquipier)
	return err
}

func (ct Controller) loadJoomeo(idEquipier int64) (DatasJoomeo, error) {
	row := ct.DB.QueryRow(`SELECT personnes.* FROM personnes 
		JOIN equipiers ON equipiers.id_personne = personnes.id
		WHERE equipiers.id = $1`, idEquipier)
	personne, err := rd.ScanPersonne(row)
	if err != nil {
		return DatasJoomeo{}, err
	}

	api, err := joomeo.InitApi(ct.joomeo)
	if err != nil {
		return DatasJoomeo{}, shared.FormatErr("Le serveur Joomeo est indisponible.", err)
	}
	defer api.Kill()

	contact, _, err := api.GetLoginFromMail(personne.Mail.ToLower())
	if err != nil {
		return DatasJoomeo{}, shared.FormatErr("L'accès à tes informations Joomeo a échoué.", err)
	}

	return DatasJoomeo{
		SpaceURL: api.SpaceURL,
		Login:    contact.Login,
		Password: contact.Password,
	}, nil
}