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

// Fournit un service global de gestion de fichiers.
package documents

import (
	"bytes"
	"database/sql"
	"encoding/json"
	"errors"
	"fmt"
	"io/ioutil"
	"mime"
	"mime/multipart"
	"net/url"
	"path"
	"strconv"
	"strings"
	"time"

	"github.com/benoitkugler/goACVE/logs"
	"github.com/benoitkugler/goACVE/server/core/apiserver"
	dm "github.com/benoitkugler/goACVE/server/core/datamodel"
	cd "github.com/benoitkugler/goACVE/server/core/documents"
	rd "github.com/benoitkugler/goACVE/server/core/rawdata"
	"github.com/benoitkugler/goACVE/server/shared"
	"github.com/labstack/echo"
)

const (
	EndPointDocument  = "/document"
	EndPointMiniature = "/miniature"

	DocumentAbsolu  = "abs" // document présent dans la base de données
	DocumentRelatif = "rel" // document généré dynamiquement
	// DocumentStatic  = "static" // document statique

	pathMiniatureError = "server/static/images/default_miniature.png"
)

const (
	ListeVetements categorieDocument = iota
	ListeParticipants
)

type Controller struct {
	shared.Controller
}

type PublicDocument struct {
	IdCrypted      string    `json:"id_crypted,omitempty"`
	NomClient      rd.String `json:"nom_client,omitempty"`
	Taille         rd.Taille `json:"taille,omitempty"`
	DateHeureModif rd.Time   `json:"date_heure_modif,omitempty"`
	UrlMiniature   string    `json:"url_miniature,omitempty"`
	UrlDownload    string    `json:"url_download,omitempty"`
}

// PublicContrainte expose de façon sécurisée une contrainte sur le
// frontend
type PublicContrainte struct {
	IdCrypted   string         `json:"id_crypted"`
	Document    PublicDocument `json:"document"` // optionnel
	Nom         rd.String      `json:"nom"`
	Description rd.String      `json:"description"`
	MaxDocs     int            `json:"max_docs"`
	JoursValide int            `json:"jours_valide"`
}

// ContrainteDocuments associe une contrainte de document
// aux documents la remplissant
type ContrainteDocuments struct {
	Contrainte PublicContrainte `json:"contrainte"`
	Docs       []PublicDocument `json:"docs"`
}

type categorieDocument int

// MetaDoc permet de retrouver le document à télécharger/miniaturiser
// à partir d'un lien crypté
type MetaDoc struct {
	IdCamp    int64
	Categorie categorieDocument
}

// Share renvoie créé les liens de partage
func (m MetaDoc) Share(p logs.Encrypteur, host string) (doc PublicDocument, err error) {
	idCrypted, err := shared.Encode(p, m)
	if err != nil {
		return doc, err
	}
	out := PublicDocument{
		IdCrypted: idCrypted,
		UrlDownload: shared.BuildUrl(host, EndPointDocument, map[string]string{
			"crypted-id": idCrypted,
			"mode":       DocumentRelatif,
		}),
		UrlMiniature: shared.BuildUrl(host, EndPointMiniature, map[string]string{
			"crypted-id": idCrypted,
			"mode":       DocumentRelatif,
		}),
	}
	switch m.Categorie {
	case ListeVetements:
		out.NomClient = "Liste de vêtements"
	case ListeParticipants:
		out.NomClient = "Liste des participants"
	}
	return out, nil
}

// loadDataForDocuments renvoie un accès contenant une base locale
// initalisée avec les données nécessaires à la génération dynamique des documents
// une erreur est renvoyé si le camp est simple
// Attention : la base locale est donc PARTIELLE.
func (ct Controller) loadDataForDocuments(idCamp int64) (dm.AccesCamp, error) {
	camp, err := rd.SelectCamp(ct.DB, idCamp)
	if err != nil {
		return dm.AccesCamp{}, err
	}
	if camp.InscriptionSimple {
		return dm.AccesCamp{}, fmt.Errorf("Le camp %s ne propose pas de documents (camp simplifié).", camp.Label())
	}

	groupes, err := rd.SelectGroupesByIdCamps(ct.DB, idCamp)
	if err != nil {
		return dm.AccesCamp{}, err
	}

	parts, err := rd.SelectParticipantsByIdCamps(ct.DB, idCamp)
	if err != nil {
		return dm.AccesCamp{}, err
	}

	rows, err := ct.DB.Query(`SELECT factures.* FROM factures 
		JOIN participants ON factures.id = participants.id_facture
		WHERE participants.id = ANY($1)`, parts.Ids().AsSQL())
	if err != nil {
		return dm.AccesCamp{}, err
	}
	facs, err := rd.ScanFactures(rows)
	if err != nil {
		return dm.AccesCamp{}, err
	}

	idsPersonnes := make(rd.Ids, 0, len(parts)+len(facs)) // non unique, mais ce n'est pas très grave
	for _, part := range parts {
		idsPersonnes = append(idsPersonnes, part.IdPersonne)
	}
	for _, fac := range facs {
		idsPersonnes = append(idsPersonnes, fac.IdPersonne)
	}

	rows, err = ct.DB.Query("SELECT * FROM personnes WHERE id = ANY($1)", idsPersonnes.AsSQL())
	if err != nil {
		return dm.AccesCamp{}, err
	}
	pers, err := rd.ScanPersonnes(rows)
	if err != nil {
		return dm.AccesCamp{}, err
	}
	base := dm.BaseLocale{Personnes: pers, Camps: rd.Camps{camp.Id: camp}, Factures: facs, Groupes: groupes, Participants: parts}
	return base.NewCamp(idCamp), nil
}

func (ct Controller) loadDocument(cryptedId string, isMin bool) ([]byte, string, error) {
	refOrigine := shared.OrDocument
	if isMin {
		refOrigine = shared.OrMiniature
	}
	idDocument, err := shared.DecodeID(ct.Signing, cryptedId, refOrigine)
	if err != nil {
		return nil, "", err
	}

	doc, err := rd.SelectDocument(ct.DB, idDocument)
	if err != nil {
		return nil, "", err
	}

	// optimisation: on ne charge pas le contenu systématiquement
	fields := "id_document, contenu, null"
	if isMin {
		fields = "id_document, null, miniature"
	}

	row := ct.DB.QueryRow(fmt.Sprintf("SELECT %s FROM contenu_documents WHERE id_document =  $1", fields), idDocument)
	contenu, err := rd.ScanContenuDocument(row)
	if err != nil {
		return nil, "", err
	}
	out := contenu.Contenu
	if isMin {
		out = contenu.Miniature
	}
	return out, doc.NomClient.String(), nil
}

func (ct Controller) genereDocument(cryptedId string, isMin bool) ([]byte, string, error) {
	var cr MetaDoc
	if err := shared.Decode(ct.Signing, cryptedId, &cr); err != nil {
		return nil, "", err
	}
	camp, err := ct.loadDataForDocuments(cr.IdCamp)
	if err != nil {
		return nil, "", err
	}
	var renderer cd.DynamicDocument

	switch cr.Categorie {
	case ListeParticipants:
		renderer = cd.NewListeParticipants(camp)
	case ListeVetements:
		renderer = cd.NewListeVetements(camp.RawData())
	default:
		return nil, "", errors.New("invalid document categorie")
	}
	pdfBytes, err := renderer.Generate()
	if err != nil {
		return nil, "", err
	}
	if isMin {
		pdfBytes, err = ComputeMiniature2(pdfBytes)
		if err != nil {
			return nil, "", err
		}
	}
	return pdfBytes, renderer.FileName(), nil
}

func Attachment(c echo.Context, filename string, doc []byte, asAttachment bool) error {
	mimeType := mime.TypeByExtension(path.Ext(filename))
	if asAttachment {
		u := url.URL{Path: filename}
		filename = u.String()
		c.Response().Header().Set("Content-Disposition", "attachment; filename="+filename)
		c.Response().Header().Set("Content-Length", strconv.Itoa(len(doc)))
	}
	return c.Blob(200, mimeType, doc)
}

func PublieDocument(p logs.Encrypteur, host string, doc rd.Document) (PublicDocument, error) {
	u := PublicDocument{
		DateHeureModif: doc.DateHeureModif,
		NomClient:      doc.NomClient,
		Taille:         doc.Taille,
	}
	idCrypted, err := shared.EncodeID(p, shared.OrDocument, doc.Id)
	if err != nil {
		return u, shared.FormatErr("Une erreur interne empêche le cryptage des informations.", err)
	}
	idCryptedMiniature, err := shared.EncodeID(p, shared.OrMiniature, doc.Id)
	if err != nil {
		return u, shared.FormatErr("Une erreur interne empêche le cryptage des informations.", err)
	}
	u.IdCrypted = idCrypted
	u.UrlDownload = shared.BuildUrl(host, EndPointDocument, map[string]string{
		"crypted-id": idCrypted,
		"mode":       DocumentAbsolu,
	})
	u.UrlMiniature = shared.BuildUrl(host, EndPointMiniature, map[string]string{
		"crypted-id": idCryptedMiniature,
		"mode":       DocumentAbsolu,
	})
	return u, nil
}

// PublieContrainte charge un éventuel document à remplir, et le publie,
// et crypte les ids.
func PublieContrainte(p logs.Encrypteur, db rd.DB, host string, contrainte rd.Contrainte) (out PublicContrainte, err error) {
	out = PublicContrainte{
		Nom:         contrainte.Nom,
		Description: contrainte.Description,
		MaxDocs:     contrainte.MaxDocs,
		JoursValide: contrainte.JoursValide,
	}
	if contrainte.IdDocument.IsNotNil() {
		aRemplir, err := rd.SelectDocument(db, contrainte.IdDocument.Int64)
		if err != nil {
			return out, err
		}
		out.Document, err = PublieDocument(p, host, aRemplir)
		if err != nil {
			return out, err
		}
	}
	out.IdCrypted, err = shared.EncodeID(p, shared.OrContrainte, contrainte.Id)
	return out, err
}

func ReceiveUpload(fileHeader *multipart.FileHeader, maxSize int64) (filename string, content []byte, err error) {
	if fileHeader.Size > maxSize {
		return "", nil, fmt.Errorf("Document trop lourd ! (%d MB)", fileHeader.Size/1000000)
	}

	f, err := fileHeader.Open()
	if err != nil {
		return "", nil, fmt.Errorf("Impossible de lire le fichier: %s", err)
	}
	defer f.Close()

	content, err = ioutil.ReadAll(f)
	if err != nil {
		return "", nil, fmt.Errorf("Impossible de lire le fichier: %s", err)
	}
	if len(content) == 0 {
		return "", nil, errors.New("Le fichier transmis est vide !")
	}
	if int64(len(content)) != fileHeader.Size {
		return "", nil, fmt.Errorf("Contenu invalide (taille %d, attendue %d)", len(content), fileHeader.Size)
	}
	return fileHeader.Filename, content, nil
}

// ReceiveUploadWithMeta lie les meta données contenues dans le champ 'meta'
// du formulaire, puis appelle `ReceiveUpload`
func ReceiveUploadWithMeta(c echo.Context, maxSize int64, meta interface{}) (filename string, content []byte, err error) {
	jsonMeta := c.FormValue("meta")
	err = json.Unmarshal([]byte(jsonMeta), meta)
	if err != nil {
		return "", nil, fmt.Errorf("Meta données invalides : %s", err)
	}
	fileHeader, err := c.FormFile("file")
	if err != nil {
		return "", nil, fmt.Errorf("Paramètres d'upload invalides : %s", err)
	}
	return ReceiveUpload(fileHeader, maxSize)
}

// uploadDocument lit la requête et appelle `saveDocument`
func (ct Controller) uploadDocument(fileHeader *multipart.FileHeader, idDocument int64) (out rd.Document, err error) {
	filename, content, err := ReceiveUpload(fileHeader, apiserver.DOCUMENT_MAX_SIZE)
	if err != nil {
		return out, err
	}

	tx, err := ct.DB.Begin()
	if err != nil {
		return out, shared.FormatErr("Base de données injoinable.", err)
	}
	doc, err := SaveDocument(tx, idDocument, content, filename, true)
	if err != nil {
		return doc, shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return doc, err
}

// SaveDocument créé la miniature et met à jour la base de données
// Renvoi le document mis à jour.
// Ne commit ou ne rollback PAS.
func SaveDocument(tx *sql.Tx, idDocument int64, fileContent []byte, filename string, allowCompress bool) (rd.Document, error) {
	doc, err := rd.SelectDocument(tx, idDocument)
	if err != nil {
		return doc, err
	}

	min := new(bytes.Buffer)
	if err := ComputeMiniature(filename, bytes.NewReader(fileContent), min); err != nil {
		return doc, fmt.Errorf("échec de la création de la miniature (taille du document d'origine :%d) : %s",
			len(fileContent), err)
	}
	if min.Len() == 0 {
		return doc, errors.New("échec de le création de la miniature : contenu vide")
	}

	if allowCompress {
		filename, fileContent, err = compressDocument(filename, fileContent)
		if err != nil {
			return doc, shared.FormatErr("Erreur pendant la compression du document.", err)
		}
	}

	err = checkDoublons(tx, fileContent, idDocument)
	if err != nil {
		return doc, err
	}

	doc.NomClient = rd.String(filename)
	doc.DateHeureModif = rd.Time(time.Now())
	doc.Taille = rd.Taille(len(fileContent)) // taille compressée

	// on supprime l'éventuel contenu ...
	_, err = rd.DeleteContenuDocumentsByIdDocuments(tx, doc.Id)
	if err != nil {
		return doc, err
	}
	// ... et on le met à jour
	contenuDoc := rd.ContenuDocument{IdDocument: doc.Id, Contenu: fileContent, Miniature: min.Bytes()}
	err = rd.InsertManyContenuDocuments(tx, contenuDoc)
	if err != nil {
		return doc, err
	}
	return doc.Update(tx)
}

// LoadDocsAndAdd charge les documents et les ajoute à l'archive, sans la fermer.
// `prefixes` peut contenir un label à ajouter au nom du document
func LoadDocsAndAdd(tx rd.DB, idsDocs rd.Ids, archive *cd.ArchiveZip, prefixes map[int64]string) error {
	rows, err := tx.Query("SELECT * FROM documents WHERE id = ANY($1)", idsDocs.AsSQL())
	if err != nil {
		return err
	}
	documents, err := rd.ScanDocuments(rows)
	if err != nil {
		return err
	}

	// contenu
	contenus, err := rd.SelectContenuDocumentsByIdDocuments(tx, idsDocs...)
	if err != nil {
		return err
	}

	for _, contenu := range contenus {
		if len(contenu.Contenu) == 0 {
			continue // un document vide (erreur dans l'upload) est ignoré
		}
		r := bytes.NewReader(contenu.Contenu)
		filename := documents[contenu.IdDocument].NomClient.String()
		if prefix := prefixes[contenu.IdDocument]; prefix != "" {
			filename = prefix + " " + filename
		}
		filename = strings.Replace(filename, "/", "-", -1) // / indique un dossier
		archive.AddFile(filename, r)
	}
	return nil
}

// ne commit pas ne rollback pas
func insertDocument(tx *sql.Tx, idPersonne, idContrainte int64, description rd.String) (rd.Document, error) {
	// on créé les metas données
	document := rd.Document{
		DateHeureModif: rd.Time(time.Now()),
		Description:    description,
	}
	document, err := document.Insert(tx)
	if err != nil {
		return rd.Document{}, err
	}

	// puis on créé le lien avec la personne et la contrainte
	docPers := rd.DocumentPersonne{
		IdDocument:   document.Id,
		IdContrainte: idContrainte,
		IdPersonne:   idPersonne,
	}
	err = rd.InsertManyDocumentPersonnes(tx, docPers)
	return document, err
}

type ParamsNewDocument struct {
	IdContrainte int64

	Description rd.String

	FileContent []byte
	FileName    string
}

// CreeDocumentPersonne les metas donnés d'un document répondant à la contrainte donnée
// pour la personne donnée, et upload le contenu
func CreeDocumentPersonne(p logs.Encrypteur, db *sql.DB, host string, idPersonne int64, params ParamsNewDocument) (PublicDocument, error) {
	tx, err := db.Begin()
	if err != nil {
		return PublicDocument{}, err
	}

	// on vérifie la 'taille' de la contrainte
	contrainte, err := rd.SelectContrainte(tx, params.IdContrainte)
	if err != nil {
		return PublicDocument{}, shared.Rollback(tx, err)
	}
	row := tx.QueryRow("SELECT count(*) FROM document_personnes WHERE id_personne = $1 AND id_contrainte = $2", idPersonne, params.IdContrainte)
	var nbDocs int
	if err = row.Scan(&nbDocs); err != nil {
		return PublicDocument{}, shared.Rollback(tx, err)
	}
	if nbDocs >= contrainte.MaxDocs {
		_ = tx.Rollback()
		return PublicDocument{}, fmt.Errorf("Le nombre maximal de documents (%d) pour la catégorie %s est atteint.",
			contrainte.MaxDocs, contrainte.Nom)
	}

	// meta données
	document, err := insertDocument(tx, idPersonne, params.IdContrainte, params.Description)
	if err != nil {
		return PublicDocument{}, shared.Rollback(tx, err)
	}

	// contenu
	document, err = SaveDocument(tx, document.Id, params.FileContent, params.FileName, true)
	if err != nil {
		return PublicDocument{}, shared.Rollback(tx, err)
	}

	out, err := PublieDocument(p, host, document)
	if err != nil {
		return PublicDocument{}, shared.Rollback(tx, err)
	}
	return out, tx.Commit()
}

// CreeDocumentEquipier les metas donnés d'un document répondant à la contrainte donnée
// pour l'équipier donné, et upload le contenu
func CreeDocumentEquipier(p logs.Encrypteur, db *sql.DB, host string, idEquipier int64, params ParamsNewDocument) (PublicDocument, error) {
	equipier, err := rd.SelectEquipier(db, idEquipier)
	if err != nil {
		return PublicDocument{}, err
	}

	return CreeDocumentPersonne(p, db, host, equipier.IdPersonne, params)
}