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

package datamodel

import (
	"sort"
	"strings"
	"time"

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

const (
	POVCentre PointOfView = iota
	POVResponsable
)

// EtatDossier stocke les informations nécessaires à l'etablissement
// de l'état d'un dossier
type EtatDossier struct {
	messages  []AccesMessage
	paiements []AccesPaiement
}

// GetEtat rassemble les données décrivant l'avancement du dossier
// (messages, paiements, ...)
func (ac AccesFacture) GetEtat(cache1 LiensFactureMessages, cache2 LiensFacturePaiements) EtatDossier {
	if cache1 == nil {
		cache1 = ac.Base.ResoudMessages()
	}
	if cache2 == nil {
		cache2 = ac.Base.ResoudPaiements()
	}
	var out EtatDossier
	for _, id := range cache1[ac.Id] {
		out.messages = append(out.messages, ac.Base.NewMessage(id))
	}
	for _, id := range cache2[ac.Id] {
		out.paiements = append(out.paiements, ac.Base.NewPaiement(id))
	}
	// on tri les messages par date de création
	sort.Slice(out.messages, func(i, j int) bool {
		return out.messages[i].RawData().Created.Time().Before(out.messages[j].RawData().Created.Time())
	})
	return out
}

func (e EtatDossier) InscriptionDateHeure() rd.Time {
	for _, message := range e.messages {
		if message.RawData().Kind == rd.MInscription {
			return message.RawData().Created
		}
	}
	return rd.Time{}
}

// LastModified renvoie le moment de la dernière action (visible)
// effectuée sur le dossier
func (e EtatDossier) LastModified() rd.Time {
	ps := e.PseudoMessages(POVCentre)
	if len(ps) == 0 {
		return rd.Time{}
	}
	// pseudo message sont triés du plus ancien au plus récent
	return ps[len(ps)-1].Created
}

func (e EtatDossier) IsFactureRappel(mFac PseudoMessage) bool {
	for _, message := range e.messages {
		isFacture := message.RawData().Kind == rd.MFacture
		isBefore := message.RawData().Created.Time().Before(mFac.Created.Time())
		isDifferent := message.Id != mFac.Id
		if isFacture && isBefore && isDifferent {
			return true
		}
	}
	return false
}

// Info aggrège les messages envoyés par le responsable
func (e EtatDossier) Info() string {
	var outs []string
	for _, mess := range e.messages {
		if mess.RawData().Kind == rd.MResponsable {
			contenu := mess.Base.MessageMessages[mess.Id]
			outs = append(outs, contenu.Contenu.TrimSpace().String())
		}
	}
	return strings.Join(outs, "\n\n")
}

// PseudoMessages expose les actions du dossier, du plus ancien au plus récent.
func (e EtatDossier) PseudoMessages(pov PointOfView) []PseudoMessage {
	out := make([]PseudoMessage, 0, len(e.messages)+len(e.paiements))
	for _, message := range e.messages {
		out = append(out, message.ToPseudo(pov))
	}
	for _, paiement := range e.paiements {
		out = append(out, paiement.ToPseudo(pov))
	}
	// détérminisme même pour les des messages simulatnés
	sort.Slice(out, func(i, j int) bool {
		return out[i].Kind < out[j].Kind
	})
	sort.SliceStable(out, func(i, j int) bool {
		return out[i].Created.Time().Before(out[j].Created.Time())
	})
	return out
}

type PointOfView uint8

func (p PointOfView) IsViewable(kind rd.MessageKind) bool {
	// côté espace perso, le marquage vu/non vu est automatique (implémenté côté serveur)
	if p == POVResponsable {
		return false
	}
	switch kind {
	case rd.MResponsable:
		return true
	default:
		return false
	}
}

func (p PointOfView) IsEditable(kind rd.MessageKind) bool {
	switch p {
	case POVCentre:
		return kind == rd.MCentre
	case POVResponsable:
		return kind == rd.MResponsable
	default:
		return false
	}
}

func (p PointOfView) IsDeletable(kind rd.MessageKind) bool {
	switch p {
	case POVCentre:
		return kind == rd.MCentre || kind == rd.MFacture || kind == rd.MDocuments || kind == rd.MFactureAcquittee || kind == rd.MAttestationPresence || kind == rd.MSondage || kind == rd.MPlaceLiberee
	case POVResponsable:
		return kind == rd.MResponsable
	default:
		return false
	}
}

// MessageLabel précise le titre d'un message libre
func (p PointOfView) MessageLabel(kind rd.MessageKind) string {
	isEnvoye := (p == POVResponsable && kind == rd.MResponsable) || (p == POVCentre && kind == rd.MCentre)
	if isEnvoye {
		return "Message envoyé"
	}
	return "Message reçu"
}

// PseudoMessage expose un évènement (message ou paiement)
type PseudoMessage struct {
	Id        int64 `json:"id"` // message ou paiement
	IdFacture int64 `json:"id_facture"`

	Label       string      `json:"label"`
	Color       rd.HexColor `json:"color"`
	Created     rd.Time     `json:"created"`
	Modified    rd.Time     `json:"modified"`
	Vu          bool        `json:"vu"`
	IsViewable  bool        `json:"is_viewable"`
	IsEditable  bool        `json:"is_editable"`
	IsDeletable bool        `json:"is_deletable"`

	Kind    rd.MessageKind `json:"kind"`
	Contenu MessageContenu `json:"contenu"`
}

// LastEvent renvoie la dernière modification (au sens large)
func (ps PseudoMessage) LastEvent() time.Time {
	if ps.Modified.Time().IsZero() {
		return ps.Created.Time()
	}
	return ps.Modified.Time()
}

// ------------- implémentations ---------------------------

// NewPseudoMessage permet de construire un pseudo message sans base locale.
func NewPseudoMessage(message rd.Message, pov PointOfView, contenu MessageContenu) PseudoMessage {
	label := message.Kind.String()
	// specialize messages perso
	if message.Kind == rd.MResponsable || message.Kind == rd.MCentre {
		label = pov.MessageLabel(message.Kind)
	}
	return PseudoMessage{
		Id:          message.Id,
		IdFacture:   message.IdFacture,
		Label:       label,
		Color:       message.Kind.Color(),
		Created:     message.Created,
		Modified:    message.Modified,
		Vu:          message.Vu,
		IsViewable:  pov.IsViewable(message.Kind),
		IsEditable:  pov.IsEditable(message.Kind),
		IsDeletable: pov.IsDeletable(message.Kind),
		Kind:        message.Kind,
		Contenu:     contenu,
	}
}

func (ac AccesMessage) ToPseudo(pov PointOfView) PseudoMessage {
	return NewPseudoMessage(ac.RawData(), pov, ac.toContenu())
}

func (ac AccesMessage) toContenu() MessageContenu {
	message := ac.RawData()
	switch message.Kind {
	case rd.MResponsable, rd.MCentre:
		return ContenuPerso(ac.Base.MessageMessages[ac.Id].Contenu)
	case rd.MDocuments:
		return ContenuDocument(ac.Base.MessageDocuments[ac.Id])
	case rd.MSondage:
		return ContenuSondage(ac.Base.MessageSondages[ac.Id])
	case rd.MPlaceLiberee:
		return ContenuPlaceLiberee(ac.Base.MessagePlaceliberes[ac.Id])
	case rd.MFactureAcquittee, rd.MAttestationPresence:
		return ContenuAttestation{Distribution: ac.Base.MessageAttestations[ac.Id].Distribution}
	}
	return nil
}

func (ac AccesPaiement) ToPseudo(_ PointOfView) PseudoMessage {
	paiement := ac.RawData()
	return PseudoMessage{
		Id:        paiement.Id,
		IdFacture: paiement.IdFacture,
		Label:     "Paiement",
		Color:     rd.MPaiement.Color(),
		Created:   paiement.DateReglement,
		Vu:        true,
		Kind:      rd.MPaiement,
		Contenu:   nil,
	}
}

// MessageContenu spécialise le contenu d'un message
type MessageContenu interface {
	isContenu()
}

// --------- implementations ----------------------

type ContenuPerso string

func (ContenuPerso) isContenu() {}

type ContenuDocument rd.MessageDocument

func (ContenuDocument) isContenu() {}

type ContenuSondage rd.MessageSondage

func (ContenuSondage) isContenu() {}

type ContenuPlaceLiberee rd.MessagePlacelibere

func (ContenuPlaceLiberee) isContenu() {}

type ContenuAttestation struct {
	Distribution rd.Distribution `json:"distribution"`
}

func (ContenuAttestation) isContenu() {}