github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/server/vote/admin.go

package vote

import (
	"bytes"
	"fmt"
	"path"
	"sort"
	"strings"
	"time"

	"github.com/benoitkugler/goACVE/server/core/rawdata"
	"github.com/benoitkugler/goACVE/server/core/utils/mails"
	"github.com/benoitkugler/goACVE/logs"
	"github.com/benoitkugler/goACVE/server/shared"
)

// --------------------- page administrateur ----------------------------

const mailSubject = "[ACVE] Vote de l'association"

func lienVote(host string, id int64) string {
	lien := logs.LienVote.Offusc(id)
	return shared.BuildUrl(host, path.Join(EndpointVote, lien), nil)
}

type idVoteTime struct {
	idVote int64
	time   time.Time
}

type timedVotes map[idVoteTime]bool

func (m timedVotes) last() time.Time {
	var out time.Time
	for k := range m {
		if k.time.After(out) {
			out = k.time
		}
	}
	return out
}

var critereMembre = fmt.Sprintf(`rang_membre_asso IN ('%s', '%s', '%s') AND (is_temporaire IS NULL OR is_temporaire = false)`,
	rawdata.RMAMembre, rawdata.RMACA, rawdata.RMABureau)

func (ct Controller) getMembres(host string) ([]Membre, error) {
	// a synchroniser avec bilans
	rows, err := ct.db.Query("SELECT * FROM personnes WHERE " + critereMembre)
	if err != nil {
		return nil, err
	}
	personnes, err := rawdata.ScanPersonnes(rows)
	if err != nil {
		return nil, err
	}
	row := ct.db.QueryRow("SELECT count(*) FROM votes")
	var nbVotes int
	if err := row.Scan(&nbVotes); err != nil {
		return nil, err
	}
	vps, err := SelectAllVotePersonnes(ct.db)
	if err != nil {
		return nil, err
	}

	// pour chaque membre, combien de votes faits
	tmp := make(map[int64]timedVotes)
	for _, vp := range vps {
		l := tmp[vp.IdPersonne]
		if l == nil {
			l = make(timedVotes)
		}
		l[idVoteTime{idVote: vp.IdVote, time: vp.Time}] = true
		tmp[vp.IdPersonne] = l
	}

	var out []Membre
	for _, pers := range personnes {
		votePers := tmp[pers.Id]
		out = append(out, Membre{
			NomPrenom: pers.FNom() + " " + pers.FPrenom(),
			Mail:      pers.Mail,
			Lien:      lienVote(host, pers.Id),
			Participation: Participation{
				Actuels: len(votePers),
				Total:   nbVotes,
				Last:    votePers.last(),
			},
		})
	}
	sort.Slice(out, func(i, j int) bool {
		return out[i].NomPrenom < out[j].NomPrenom
	})
	return out, nil
}

type nomLien struct {
	NomPrenom string
	Lien      string
}

type mailArgs struct {
	Title             string
	FooterTitle       string
	FooterInfos       string
	SignatureMail     string
	MessagePersoLines []string
	Liens             []nomLien
}

func (ct Controller) genereMail(liens []nomLien) (string, error) {
	args := mailArgs{
		Title:         "Vote en ligne",
		FooterTitle:   rawdata.Asso.Title,
		FooterInfos:   rawdata.Asso.Infos,
		SignatureMail: "<i>Ceci est un mail automatique, merci de ne pas y répondre.</i>",
		Liens:         liens,
	}
	var out bytes.Buffer
	err := ct.templateMail.ExecuteTemplate(&out, "base.html", args)
	return out.String(), err
}

func (ct Controller) inviteOne(membre Membre) error {
	mailHtml, err := ct.genereMail([]nomLien{{NomPrenom: membre.NomPrenom, Lien: membre.Lien}})
	if err != nil {
		return err
	}
	return mails.NewMailer(ct.smtp).SendMail(membre.Mail.String(), mailSubject, mailHtml, nil, nil)
}

func (ct Controller) inviteAll(host string) error {
	membres, err := ct.getMembres(host)
	if err != nil {
		return err
	}
	// on regroupe les personnes par adresse mail
	parMail := make(map[string][]nomLien)
	for _, membre := range membres {
		mail := membre.Mail.TrimSpace().ToLower()
		parMail[mail] = append(parMail[mail], nomLien{NomPrenom: membre.NomPrenom, Lien: membre.Lien})
	}
	// on ignore les mails vides
	delete(parMail, "")

	pool, err := mails.NewPool(ct.smtp, nil)
	if err != nil {
		return err
	}
	defer pool.Close()
	var errs []string
	for to, personnes := range parMail {
		mailHtml, err := ct.genereMail(personnes)
		if err != nil {
			errs = append(errs, err.Error())
			continue
		}
		err = pool.SendMail(to, mailSubject, mailHtml, nil, nil)
		if err != nil {
			errs = append(errs, err.Error())
			continue
		}
	}
	if len(errs) > 0 {
		return fmt.Errorf("Certains mails n'ont pas été envoyés : <br/> %s", strings.Join(errs, "<br/>"))
	}
	return nil
}

func (ct Controller) addDecompte(votes []VoteCandidats) ([]VoteAdmin, error) {
	actions, err := SelectAllVotePersonnes(ct.db)
	if err != nil {
		return nil, err
	}
	// on compte les actions par votes
	allActions := make(map[int64]int)
	for _, ac := range actions {
		allActions[ac.IdVote]++
	}

	voix, err := SelectAllVotePersonneCandidats(ct.db)
	if err != nil {
		return nil, err
	}
	// on compte les voix par candidats
	allVoix := make(map[int64]int)
	for _, v := range voix {
		allVoix[v.IdCandidat]++
	}

	out := make([]VoteAdmin, len(votes))
	// on récupère les voix
	for i, v := range votes {
		va := VoteAdmin{VoteCandidats: v, Voix: make(map[int64]int), Participation: allActions[v.Id]}
		for _, candidat := range va.Candidats {
			va.Voix[candidat.Id] = allVoix[candidat.Id]
		}
		out[i] = va
	}
	return out, nil
}

func (ct Controller) getVotes() ([]VoteCandidats, error) {
	votes, err := SelectAllVotes(ct.db)
	if err != nil {
		return nil, err
	}
	candidats, err := SelectAllCandidats(ct.db)
	if err != nil {
		return nil, err
	}

	// on regroupe les candidats par vote
	tmp := make(map[int64][]Candidat) // id vote -> candidats
	for _, candidat := range candidats {
		tmp[candidat.IdVote] = append(tmp[candidat.IdVote], candidat)
	}
	var out []VoteCandidats
	for _, vote := range votes {
		cds := tmp[vote.Id]
		sort.Slice(cds, func(i, j int) bool {
			return cds[i].Id < cds[j].Id
		})
		out = append(out, VoteCandidats{
			Vote:      vote,
			Candidats: cds,
		})
	}
	sort.Slice(out, func(i, j int) bool {
		return out[i].Id < out[j].Id
	})
	return out, nil
}

func (ct Controller) getVotesWithDecompte() ([]VoteAdmin, error) {
	votes, err := ct.getVotes()
	if err != nil {
		return nil, err
	}
	return ct.addDecompte(votes)
}

// vote est complété
func (ct Controller) createVote(vote VoteCandidats) error {
	tx, err := ct.db.Begin()
	if err != nil {
		return err
	}
	vote.Vote, err = vote.Vote.Insert(tx)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	for _, c := range vote.Candidats {
		c.IdVote = vote.Id // on utilise l'id nouvellement attribué
		_, err := c.Insert(tx)
		if err != nil {
			return shared.Rollback(tx, err)
		}
	}
	return tx.Commit()
}

// modification seulement si aucune voix
func (ct Controller) updateVote(vote VoteCandidats) error {
	voix, err := SelectVotePersonneByIdVote(ct.db, vote.Id)
	if err != nil {
		return err
	}
	if len(voix) > 0 {
		return fmt.Errorf("Ce vote a déjà reçu des suffrages, les modifications sont donc désactivées.")
	}

	tx, err := ct.db.Begin()
	if err != nil {
		return err
	}
	vote.Vote, err = vote.Vote.Update(tx)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	// on remet à zéro les choix
	_, err = tx.Exec("DELETE FROM candidats WHERE id_vote = $1", vote.Id)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	// puis on insère les nouveaux
	for _, c := range vote.Candidats {
		c.IdVote = vote.Id
		_, err := c.Insert(tx)
		if err != nil {
			return shared.Rollback(tx, err)
		}
	}
	return tx.Commit()
}

func (ct Controller) lockVote(params LockVote) (Vote, error) {
	row := ct.db.QueryRow("UPDATE votes SET is_locked = $1 WHERE id = $2 RETURNING *", params.IsLocked, params.IdVote)
	return ScanVote(row)
}

func (ct Controller) clearVote(id int64) error {
	tx, err := ct.db.Begin()
	if err != nil {
		return err
	}
	_, err = tx.Exec("DELETE FROM vote_personne_candidats WHERE id_vote = $1", id)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	_, err = tx.Exec("DELETE FROM vote_personnes WHERE id_vote = $1", id)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return err
}

func (ct Controller) deleteVote(id int64) error {
	tx, err := ct.db.Begin()
	if err != nil {
		return err
	}
	// liens
	_, err = tx.Exec("DELETE FROM vote_personne_candidats WHERE id_vote = $1", id)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	_, err = tx.Exec("DELETE FROM vote_personnes WHERE id_vote = $1", id)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	_, err = tx.Exec("DELETE FROM candidats WHERE id_vote = $1", id)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	_, err = Vote{Id: id}.Delete(tx)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	return tx.Commit()
}

func (ct Controller) exportBilanVotes() ([]byte, error) {
	votes, err := ct.getVotesWithDecompte()
	if err != nil {
		return nil, err
	}

	// on compte les voix exprimées
	votePersonnes, err := SelectAllVotePersonnes(ct.db)
	if err != nil {
		return nil, err
	}
	tmp := make(map[int64]int)
	for _, vp := range votePersonnes {
		tmp[vp.IdVote]++
	}

	row := ct.db.QueryRow("SELECT count(*) FROM personnes WHERE " + critereMembre)
	var nbTotal int
	if err := row.Scan(&nbTotal); err != nil {
		return nil, err
	}

	var vps []voteParticipants
	for _, vote := range votes {
		if !vote.IsLocked {
			continue // on ignore les votes non verouillés
		}
		vps = append(vps, voteParticipants{
			VoteAdmin:      vote,
			nbParticipants: tmp[vote.Id],
			nbTotal:        nbTotal,
		})
	}
	if len(vps) == 0 {
		return nil, fmt.Errorf("Aucun vote à exporter. Merci de <b>clôturer</b> les votes que vous voulez exporter.")
	}
	return genereBilanVotes(vps)
}