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

package espaceperso

import (
	"fmt"
	"time"

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

const deltaVu = 30 * time.Minute // retarde le passage non vu -> vu

func isOld(message dm.PseudoMessage, lastCo time.Time) bool {
	k := message.Kind

	// exception pour les messages écrits par les parents .. ou supprimés ..
	isResp := k == rd.MResponsable
	isSuppr := k == rd.MSupprime
	// ... pour les place libérées "répondues"
	isPlrep := k == rd.MPlaceLiberee && !message.Modified.Time().IsZero()

	// .. et pour les attestations /factures téléchargées
	isDownload := false
	if k == rd.MFactureAcquittee || k == rd.MAttestationPresence {
		if d, ok := message.Contenu.(dm.ContenuAttestation); ok {
			isDownload = d.Distribution == rd.DEspacePerso || d.Distribution == rd.DMailAndDownload
		}
	} else if k == rd.MFacture {
		isDownload = !message.Modified.Time().IsZero()
	}

	// .. sinon, basé sur la dernière connection
	nouveau := lastCo.Before(message.LastEvent().Add(deltaVu))

	return isResp || isDownload || isSuppr || isPlrep || !nouveau
}

func (ct Controller) creeMessage(idFacture int64, contenu rd.String) (dm.PseudoMessage, error) {
	tx, err := ct.DB.Begin()
	if err != nil {
		return dm.PseudoMessage{}, err
	}
	// on crée le message ...
	message := rd.Message{IdFacture: idFacture, Created: rd.Time(time.Now()), Kind: rd.MResponsable}
	message, err = message.Insert(tx)
	if err != nil {
		return dm.PseudoMessage{}, shared.Rollback(tx, err)
	}
	// ... et le contenu
	mMessage := rd.MessageMessage{IdMessage: message.Id, Contenu: contenu, GuardKind: message.Kind}
	err = rd.InsertManyMessageMessages(tx, mMessage)
	if err != nil {
		return dm.PseudoMessage{}, shared.Rollback(tx, err)
	}
	err = tx.Commit()
	out := dm.NewPseudoMessage(message, dm.POVResponsable, dm.ContenuPerso(mMessage.Contenu))
	// un message envoyé depuis l'espace perso est forcément vu
	out.Vu = true
	return out, err
}

func (ct Controller) editMessage(idFacture int64, modif EditMessage) (dm.PseudoMessage, error) {
	tx, err := ct.DB.Begin()
	if err != nil {
		return dm.PseudoMessage{}, err
	}
	row := tx.QueryRow("UPDATE messages SET modified = $1 WHERE id = $2 RETURNING *", time.Now(), modif.Id)
	message, err := rd.ScanMessage(row)
	if err != nil {
		return dm.PseudoMessage{}, shared.Rollback(tx, err)
	}

	// on vérifie les contraintes de sécurité
	if message.IdFacture != idFacture {
		_ = shared.Rollback(tx, nil)
		return dm.PseudoMessage{}, fmt.Errorf("Ce message ne vous appartient pas.")
	}
	if message.Kind != rd.MResponsable {
		_ = shared.Rollback(tx, nil)
		return dm.PseudoMessage{}, fmt.Errorf("Seul est un message libre est modifiable.")
	}

	// on modifie le contenu
	row = tx.QueryRow("UPDATE message_messages SET contenu = $1 WHERE id_message = $2 RETURNING *", modif.Contenu, message.Id)
	mMessage, err := rd.ScanMessageMessage(row)
	if err != nil {
		return dm.PseudoMessage{}, shared.Rollback(tx, err)
	}
	err = tx.Commit()
	out := dm.NewPseudoMessage(message, dm.POVResponsable, dm.ContenuPerso(mMessage.Contenu))
	// un message envoyé depuis l'espace perso est forcément vu
	out.Vu = true
	return out, err
}

// marque le message comme supprimé
func (ct Controller) deleteMessage(idFacture, idMessage int64) (dm.PseudoMessage, error) {
	tx, err := ct.DB.Begin()
	if err != nil {
		return dm.PseudoMessage{}, err
	}

	// on vérifie la sécurité
	message, err := rd.SelectMessage(tx, idMessage)
	if err != nil {
		return dm.PseudoMessage{}, shared.Rollback(tx, err)
	}
	if message.IdFacture != idFacture {
		_ = shared.Rollback(tx, nil)
		return dm.PseudoMessage{}, fmt.Errorf("Ce message ne vous appartient pas.")
	}
	if message.Kind != rd.MResponsable {
		_ = shared.Rollback(tx, nil)
		return dm.PseudoMessage{}, fmt.Errorf("Seul est un message libre est supprimable.")
	}

	// on supprime les liens ...
	_, err = rd.DeleteMessageMessagesByIdMessages(tx, message.Id)
	if err != nil {
		return dm.PseudoMessage{}, shared.Rollback(tx, err)
	}
	// ... puis on modifie le type
	message.Kind = rd.MSupprime
	message.Modified = rd.Time(time.Now())
	message, err = message.Update(tx)
	if err != nil {
		return dm.PseudoMessage{}, shared.Rollback(tx, err)
	}
	err = tx.Commit()
	out := dm.NewPseudoMessage(message, dm.POVResponsable, nil)
	// un message envoyé depuis l'espace perso est forcément vu
	out.Vu = true
	return out, err
}

// vérifie qu'un message place libérée existe, puis passe le participant en liste
// principale
func (ct Controller) confirmePlaceliberee(idFacture int64, idMessage int64) error {
	message, err := rd.SelectMessage(ct.DB, idMessage)
	if err != nil {
		return err
	}
	if message.Kind != rd.MPlaceLiberee {
		return fmt.Errorf("Le message transmis est invalide.")
	}
	mP, found, err := rd.SelectMessagePlacelibereByIdMessage(ct.DB, message.Id)
	if err != nil {
		return err
	}
	if !found {
		return fmt.Errorf("Le contenu du message Place libérée est introuvable.")
	}
	part, err := rd.SelectParticipant(ct.DB, mP.IdParticipant)
	if err != nil {
		return err
	}
	tx, err := ct.DB.Begin()
	if err != nil {
		return err
	}
	// on modifie le participant ...
	part.ListeAttente.Statut = rd.Inscrit
	_, err = part.Update(tx)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	// ... et le message
	_, err = tx.Exec("UPDATE messages SET modified = $1 WHERE id = $2", time.Now(), message.Id)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return err
}