github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/server/shared/utils.go

// Implémente divers utilitaires communs
// aux controllers du serveur.
package shared

import (
	"database/sql"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
	"net/url"
	"strconv"
	"strings"

	rd "github.com/benoitkugler/goACVE/server/core/rawdata"
	"github.com/labstack/echo"

	"github.com/benoitkugler/goACVE/logs"
)

type Controller struct {
	SMTP    logs.SMTP
	DB      *sql.DB
	Signing logs.Encrypteur
}

type CampMeta struct {
	Id         int64     `json:"id"`
	Label      rd.String `json:"label"`
	Terminated bool      `json:"terminated"`
}

type Camp struct {
	CampMeta
	Description    string            `json:"description"`
	Prix           rd.Euros          `json:"prix"`
	Options        rd.OptionsCamp    `json:"options"`
	OptionPrix     rd.OptionPrixCamp `json:"option_prix"`
	SchemaPaiement rd.SchemaPaiement `json:"schema_paiement"`
	DateDebut      rd.Date           `json:"date_debut"`
	DateFin        rd.Date           `json:"date_fin"`
	AgeMin         rd.Int            `json:"age_min"`
	AgeMax         rd.Int            `json:"age_max"`
	IsSimple       bool              `json:"is_simple"`
	Infos          rd.String         `json:"infos"`
}

func (c *Camp) From(camp rd.Camp) {
	c.Id = camp.Id
	c.Label = camp.Label()
	c.Description = camp.Description()
	c.Terminated = camp.IsTerminated()
	c.Prix = camp.Prix
	c.Options = camp.Options
	c.OptionPrix = camp.OptionPrix
	c.SchemaPaiement = camp.SchemaPaiement
	c.AgeMax = camp.AgeMax
	c.AgeMin = camp.AgeMin
	c.DateDebut = camp.DateDebut
	c.DateFin = camp.DateFin
	c.IsSimple = bool(camp.InscriptionSimple)
	c.Infos = camp.Infos
}

// Rollback tente un rollback et forward la raison ou renvoie
// l'erreur du rollback
func Rollback(tx *sql.Tx, raison error) error {
	if errRb := tx.Rollback(); errRb != nil {
		return fmt.Errorf("Erreur pendant l'annulation de la transaction : %s", errRb)
	}
	if _, isErrorSQL := raison.(formattedError); isErrorSQL {
		// on n'ajoute pas de contexte
		return raison
	}
	return FormatErr("La requête SQL a échouée.", raison)
}

type formattedError struct {
	error
}

func FormatErr(explication string, details error) error {
	return formattedError{fmt.Errorf(explication+"<br/> Détails : <i>%s</i>", details)}
}

func BuildUrl(host, path string, params map[string]string) string {
	pm := url.Values{}
	for k, v := range params {
		pm.Add(k, v)
	}
	u := url.URL{
		Host:     host,
		Scheme:   "https",
		Path:     path,
		RawQuery: pm.Encode(),
	}
	if strings.HasPrefix(host, "localhost") {
		u.Scheme = "http"
	}
	return u.String()
}

// DeletePersonne supprime la personne temporaire ainsi que ses documents.
// Si la personne n'est pas temporaire rien n'est fait.
//
// Ne commit PAS, ne rollback PAS
//
// Renvoi les ids des documents supprimés.
func DeletePersonne(tx rd.DB, idPersonne int64) (isTemporaire bool, docs rd.Ids, err error) {
	personne, err := rd.SelectPersonne(tx, idPersonne)
	if err != nil {
		return false, nil, err
	}
	if !personne.IsTemporaire {
		return false, nil, nil
	}

	rows, err := tx.Query("DELETE FROM document_personnes WHERE id_personne = $1 RETURNING id_document", idPersonne)
	if err != nil {
		return false, nil, err
	}
	deletedDocs, err := rd.ScanIds(rows)
	if err != nil {
		return false, nil, err
	}

	_, err = rd.DeleteDocumentsByIds(tx, deletedDocs...)
	if err != nil {
		return false, nil, err
	}

	_, err = rd.DeletePersonneById(tx, personne.Id)
	if err != nil {
		return false, nil, err
	}
	return true, deletedDocs, nil
}

type DocumentsData struct {
	Documents   rd.Documents
	Contraintes rd.Contraintes
	Liens       map[int64]rd.DocumentPersonne
}

// LoadDocuments renvoie les documents des personnes demandées
func (ct Controller) LoadDocuments(idsPersonnes rd.Ids) (DocumentsData, error) {
	var out DocumentsData
	docPers, err := rd.SelectDocumentPersonnesByIdPersonnes(ct.DB, idsPersonnes...)
	if err != nil {
		return out, err
	}
	out.Liens = docPers.ByIdDocument()

	rows, err := ct.DB.Query(`SELECT documents.* FROM documents
		JOIN document_personnes ON document_personnes.id_document = documents.id
		WHERE document_personnes.id_personne = ANY($1)`, idsPersonnes.AsSQL())
	if err != nil {
		return out, err
	}
	out.Documents, err = rd.ScanDocuments(rows)
	if err != nil {
		return out, err
	}

	rows, err = ct.DB.Query(`SELECT contraintes.* FROM contraintes 
		JOIN document_personnes ON document_personnes.id_contrainte = contraintes.id
		WHERE document_personnes.id_document = ANY($1)`, out.Documents.Ids().AsSQL())
	if err != nil {
		return out, err
	}
	out.Contraintes, err = rd.ScanContraintes(rows)

	return out, err
}

// GetNewKey renvoie une clé de facture non utilisée.
func GetNewKey(tx *sql.Tx) (string, error) {
	rows, err := tx.Query("SELECT key FROM factures")
	if err != nil {
		return "", err
	}
	defer rows.Close()
	keys := make(map[string]bool)
	for rows.Next() {
		key := new(sql.NullString)
		if err = rows.Scan(key); err != nil {
			return "", err
		}
		if key.Valid {
			keys[key.String] = true
		}
	}

	if err = rows.Err(); err != nil {
		return "", err
	}
	newKey := rd.RandString(64, false)
	for keys[newKey] { // on essaie jusqu'à trouver une nouvelle
		newKey = rd.RandString(64, false)
	}
	return newKey, nil
}

// ParseId renvoie le paramètre 'field' de l'url
func ParseId(c echo.Context, field string) (int64, error) {
	idS := c.QueryParam(field)
	id, err := strconv.ParseInt(idS, 10, 0)
	if err != nil {
		return 0, FormatErr("Identifiant invalide.", err)
	}
	return id, nil
}

// WriteMultipart crée une réponse multipart et écrit
// chaque champs présent dans `data`. Retourne aussi FormDataContentType
func WriteMultipart(header http.Header, w io.Writer, data map[string][]byte) error {
	mw := multipart.NewWriter(w)
	header.Set("Content-Type", mw.FormDataContentType())
	for key, value := range data {
		fw, err := mw.CreateFormField(key)
		if err != nil {
			return err
		}
		if _, err := fw.Write(value); err != nil {
			return err
		}
	}
	err := mw.Close()
	return err
}