github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/server/directeurs/lettre.go

package directeurs

import (
	"errors"
	"fmt"
	"log"
	"mime"
	"mime/multipart"
	"net/url"
	"path/filepath"
	"strings"
	"time"

	rd "github.com/benoitkugler/goACVE/server/core/rawdata"
	"github.com/benoitkugler/goACVE/server/core/utils/pdf"
	"github.com/benoitkugler/goACVE/server/documents"
	"github.com/benoitkugler/goACVE/server/shared"
	"github.com/labstack/echo"
	"github.com/lib/pq"
	"golang.org/x/net/html"
	"golang.org/x/net/html/atom"
)

const (
	MAX_IMAGE_SIZE          = 1000000 // bytes
	PATH_LOAD_IMAGES_LETTRE = "/api/imageslettre"
)

func GenerateNewImageLien(db rd.DB) (string, error) {
	newLien := rd.RandString(64, false)
	for {
		row := db.QueryRow("SELECT count(*) FROM imageuploadeds WHERE lien = $1", newLien)
		var count int
		if err := row.Scan(&count); err != nil {
			return "", err
		}
		if count == 0 { // OK, le lien est libre
			break
		}
		newLien = rd.RandString(64, false) // déjà pris, on ré-essaye
	}
	return newLien, nil
}

func GetImagePublicURL(host, lien string) string {
	return shared.BuildUrl(host, PATH_LOAD_IMAGES_LETTRE, map[string]string{"lien": lien})
}

func (ct Controller) uploadImageLettre(fileHeader *multipart.FileHeader, host string, idCamp int64) (string, error) {
	filename, content, err := documents.ReceiveUpload(fileHeader, MAX_IMAGE_SIZE)
	if err != nil {
		return "", err
	}

	lien, err := GenerateNewImageLien(ct.DB)
	if err != nil {
		return "", err
	}

	tx, err := ct.DB.Begin()
	if err != nil {
		return "", err
	}

	img := rd.Imageuploaded{IdCamp: idCamp, Filename: filename, Content: content, Lien: lien}
	err = rd.InsertManyImageuploadeds(tx, img)
	if err != nil {
		return "", shared.Rollback(tx, err)
	}
	err = tx.Commit()

	location := GetImagePublicURL(host, lien)

	return location, err
}

type urlAuth struct {
	idCamp, token string
}

func (u urlAuth) BasicAuth() (username, password string, ok bool) {
	return u.idCamp, u.token, true
}

// Location of the image as expected by Tinymce
type UploadImageLettreOut struct {
	Location string `json:"location"`
}

// UploadImageLettre enregistre une image de la lettre au directeur
// et renvoie un chemin d'accès.
func (ct Controller) UploadImageLettre(c echo.Context) error {
	idCampS, token := c.Param("id_camp"), c.Param("token")
	idCamp, _, err := ct.authentifie(urlAuth{idCamp: idCampS, token: token})
	if err != nil {
		return err
	}
	host := c.Request().Host
	fileHeader, err := c.FormFile("file")
	if err != nil {
		return err
	}
	location, err := ct.uploadImageLettre(fileHeader, host, idCamp)
	if err != nil {
		return err
	}
	out := UploadImageLettreOut{Location: location}
	return c.JSON(200, out)
}

// LoadImageLettre renvoie l'image demandée. La sécurité est assurée
// par la complexité du lien
func (ct Controller) LoadImageLettre(c echo.Context) error {
	lien := c.QueryParam("lien")
	// dans le cas ou plusieurs images ont le même lien (copie d'une lettre d'une année sur l'autre)
	// une seule a besoin d'être renvoyée : on limite
	row := ct.DB.QueryRow("SELECT * FROM imageuploadeds WHERE lien = $1 LIMIT 1", lien)
	img, err := rd.ScanImageuploaded(row)
	if err != nil {
		return err
	}
	return c.Blob(200, mime.TypeByExtension(filepath.Ext(img.Filename)), img.Content)
}

// updateLettreDirecteur enregistre le html et génère et enregistre le document associé.
// S'il existe, le document est remplacé.
// La mise à jour de la lettre se fait en 6 étapes :
//  0. mise à jour des paramètres (html + options)
//	1. la lecture ou la création des méta-données du document final (Document)
//	2. la génération du Pdf, via weasyprint
//  3. l'enregistrement du Pdf comme contenu du document
//	4. le partage du document final
//	5. le nettoyage (en arrière plan) des images non utilisées
// Dans le cas où la lettre n'a pas été modifié, la seule étape nécessaire est l'étape 4
func (d DriverCampComplet) updateLettreDirecteur(host string, lettre rd.Lettredirecteur) (pub documents.PublicDocument, err error) {
	var (
		pdfContent []byte
		dirPers    rd.Personne
		fileName   string
	)

	tx, err := d.DB.Begin()
	if err != nil {
		return
	}

	// Etape 0: on prépare les paramètres de la lettre
	lettre.IdCamp = d.camp.Id
	lettre.Html = sanitizeHtml(lettre.Html) // sécurité + problèmes weasyprint

	// Etape 2
	docs, err := rd.SelectDocumentCampsByIdCamps(tx, d.camp.Id)
	if err != nil {
		err = shared.Rollback(tx, err)
		return
	}
	lienDoc, hasFinalDocument := docs.FindLettre()
	var docLettre rd.Document
	if hasFinalDocument { // on récupère le document final déjà existant
		docLettre, err = rd.SelectDocument(tx, lienDoc.IdDocument)
		if err != nil {
			err = shared.Rollback(tx, err)
			return
		}
	} else { // pas encore de doc associé, on crée
		docLettre = rd.Document{
			Description:    "Généré à partir de la lettre du directeur.",
			DateHeureModif: rd.Time(time.Now()),
		}
		docLettre, err = docLettre.Insert(tx)
		if err != nil {
			err = shared.Rollback(tx, err)
			return
		}
		lienDoc = rd.DocumentCamp{IdCamp: d.Camp().Id, IdDocument: docLettre.Id, IsLettre: true}
		err = rd.InsertManyDocumentCamps(tx, lienDoc)
		if err != nil {
			err = shared.Rollback(tx, err)
			return
		}
	}

	// Pour optimiser l'affichage, on commence par vérifier si le contenu a changé
	// (et si il y a déjà un document final enregistré)
	currentLettre, hasCurrentLettre, err := rd.SelectLettredirecteurByIdCamp(tx, d.camp.Id)
	if err != nil {
		err = shared.Rollback(tx, err)
		return
	}
	if hasCurrentLettre && currentLettre == lettre && hasFinalDocument {
		// la génération et l'enregistrement n'est pas nécessaire
		goto Publie
	}

	// on efface un doublon potentiel
	err = lettre.Delete(tx)
	if err != nil {
		err = shared.Rollback(tx, err)
		return
	}
	// et on insère
	err = rd.InsertManyLettredirecteurs(tx, lettre)
	if err != nil {
		err = shared.Rollback(tx, err)
		return
	}

	// Etape 2
	if !lettre.UseCoordCentre {
		eqs, err := rd.SelectEquipiersByIdCamps(tx, d.camp.Id)
		if err != nil {
			err = shared.Rollback(tx, err)
			return pub, err
		}
		dir, has := eqs.FindDirecteur()
		if !has {
			err = shared.Rollback(tx, errors.New("Aucun directeur n'est déclaré pour ce camp !"))
			return pub, err
		}
		dirPers, err = rd.SelectPersonne(tx, dir.IdPersonne)
		if err != nil {
			err = shared.Rollback(tx, err)
			return pub, err
		}
	}

	pdfContent, err = pdf.LettreDirecteur(lettre, dirPers)
	if err != nil {
		err = shared.Rollback(tx, err)
		return
	}

	// Etape 3
	fileName = fmt.Sprintf("Lettre du directeur %s.pdf", reduitNom(d.camp.RawData().Label().String()))
	docLettre, err = documents.SaveDocument(tx, docLettre.Id, pdfContent, fileName, false)
	if err != nil {
		err = shared.Rollback(tx, err)
		return
	}

Publie:

	// Etape4
	pub, err = documents.PublieDocument(d.Signing, host, docLettre)
	if err != nil {
		err = shared.Rollback(tx, err)
		return
	}

	// Etape 5
	err = tx.Commit()
	if err == nil {
		// tout est OK, on peut lancer le nettoyage en tache de fond
		go d.garbageCollectImages(lettre.Html)
	}

	return pub, err
}

func extractImagesLiens(htmlLettre string) []string {
	node, err := html.Parse(strings.NewReader(htmlLettre))
	if err != nil {
		log.Println("error extracting images", err)
		return nil
	}
	var (
		f   func(n *html.Node)
		out []string
	)
	f = func(n *html.Node) {
		if n.Type == html.ElementNode && n.DataAtom == atom.Img {
			for _, attr := range n.Attr {
				if attr.Key == "src" { // found an image
					parsed, err := url.Parse(attr.Val)
					if err != nil {
						log.Println("error parsing image url", err)
						continue
					}
					lien := parsed.Query().Get("lien")
					out = append(out, lien)
				}
			}
		}
		for c := n.FirstChild; c != nil; c = c.NextSibling {
			f(c)
		}
	}
	f(node)
	return out
}

func (d DriverCampComplet) garbageCollectImages(htmlLettre string) {
	usedLiens := extractImagesLiens(htmlLettre)
	// on supprime les images non utilisées, uniquement pour le séjour courant
	// car un même lien peut-être partagé entre 2 séjours
	res, err := d.DB.Exec("DELETE FROM imageuploadeds WHERE id_camp = $1 AND NOT (lien = ANY($2))", d.camp.Id, pq.StringArray(usedLiens))
	if err != nil {
		log.Println("error removing unsued images", err)
		return
	}
	if rowsNb, _ := res.RowsAffected(); rowsNb > 0 {
		log.Printf("camp %d -> removed %d unused images\n", d.camp.Id, rowsNb)
	}
}