github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/client/controllers/main_documents.go

package controllers

import (
	"fmt"
	"io/ioutil"
	"net/http"
	"os"
	"path/filepath"

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

// --------------------------------------------------------------
// ---------------- Fonctionnalités partagées -------------------
// --------------------------------------------------------------

// LoadMiniatures demande au serveur les miniatures associés aux ids
// fournis. Devrait être utilisée dans une goroutine.
func LoadMiniatures(idDocs rd.Ids) (map[int64][]byte, error) {
	var docs rd.ContenuDocuments
	err := requete(apiserver.UrlDocumentsMiniatures, http.MethodPost, idDocs, &docs)
	if err != nil {
		return nil, err
	}
	out := make(map[int64][]byte, len(docs))
	for _, cd := range docs {
		out[cd.IdDocument] = cd.Miniature
	}
	return out, nil
}

func (c *MainController) UpdateDocument(doc rd.Document) *rd.Document {
	c.ShowStandard("Modifications du document...", true)
	var out rd.Document
	err := requete(apiserver.UrlDocuments, http.MethodPost, doc, &out)
	if err != nil {
		c.ShowError(err)
		return nil
	}
	c.Base.Documents[out.Id] = out
	c.ShowStandard("Document mis à jour avec succès.", false)
	return &out
}

// SupprimeDocument supprime le document de manière synchrone
func (c *MainController) SupprimeDocument(id int64) {
	c.ShowStandard("Suppression du document...", true)
	var out rd.Contraintes
	err := requete(apiserver.UrlDocuments, http.MethodDelete, IdAsParams(id), &out)
	if err != nil {
		c.ShowError(err)
		return
	}
	c.Base.CleanupDocuments(rd.Ids{id})
	for k, v := range out {
		c.Base.Contraintes[k] = v
	}
	c.ShowStandard("Document supprimé avec succès.", false)
}

func (c *MainController) loadCheck(docPath string) *os.File {
	info, err := os.Stat(docPath)
	if err != nil {
		c.ShowError(err)
		return nil
	}
	if info.Size() > apiserver.DOCUMENT_MAX_SIZE {
		c.ShowError(fmt.Errorf("Le document est trop lourd : taille limite de <i>%d MB</i>, taille du document <b>%d KB</b> !",
			apiserver.DOCUMENT_MAX_SIZE/1000000, info.Size()/1000))
		return nil
	}
	f, err := os.Open(docPath)
	if err != nil {
		c.ShowError(err)
		return nil
	}
	return f
}

// uploadDocument upload le contenu sur le serveur et renvoi le document mis à jour.
func uploadDocument(idDoc int64, filename string, file *os.File,
	monitor func(uint8)) (rd.Document, error) {
	params := apiserver.ParamsUploadDocument{
		Filename: filename,
		Content:  file,
		Id:       idDoc,
	}
	var out rd.Document
	err := requeteUpload(params, monitor, &out)
	if err != nil {
		return out, err
	}
	return out, nil
}

func (c *MainController) UploadDocument(docPath string, idDoc int64, monitor func(uint8)) *rd.Document {
	file := c.loadCheck(docPath)
	if file == nil {
		return nil
	}
	c.ShowStandard("Téléversement vers le serveur...", true)
	out, err := uploadDocument(idDoc, filepath.Base(docPath), file, monitor)
	if err != nil {
		c.ShowError(err)
		return nil
	}
	c.Base.Documents[out.Id] = out
	c.ShowStandard("Document téléversé avec succès", false)
	return &out
}

func (c *MainController) CreeUploadDocument(docPath string, doc rd.Document, target rd.TargetDocument, monitor func(uint8)) {
	file := c.loadCheck(docPath)
	if file == nil {
		return
	}
	c.ShowStandard("Téléversement du document...", true)
	meta := apiserver.CreateDocumentIn{Document: doc, Target: target}
	out, err := requeteCreateDocument(ParamsNewDocument{
		fileUpload: fileUpload{name: filepath.Base(docPath), content: file},
		Meta:       meta,
	}, monitor)
	if err != nil {
		c.ShowError(err)
		return
	}
	out.Target.UpdateLinks(&c.Base.Links)
	c.Base.Documents[out.Document.Id] = out.Document
	c.ShowStandard("Document téléversé avec succès", false)
}

// DownloadDocument télécharge un document depuis la base de données,
// l'enregistre dans le dossier "local" et renvoie le chemin.
func (c *MainController) DownloadDocument(idDoc int64, monitor func(uint8)) string {
	doc := c.Base.Documents[idDoc]

	if monitor == nil {
		monitor = func(m uint8) {}
	}
	docPath, err := filepath.Abs(filepath.Join(LocalFolder, string(doc.NomClient)))
	if err != nil {
		c.ShowError(err)
		return ""
	}
	f, err := os.Create(docPath)
	if err != nil {
		c.ShowError(err)
		return ""
	}
	err = requestDownload(apiserver.UrlDocumentsTransfert, http.MethodGet, IdAsParams(idDoc), monitor, f)
	if err != nil {
		c.ShowError(err)
		return ""
	}
	if err := f.Close(); err != nil {
		c.ShowError(err)
		return ""
	}
	c.ShowStandard("Document téléchargé avec succès dans "+docPath, false)
	return docPath
}

// SaveFile enregistre un document dans le dossier "local" et renvoie le chemin.
// S'occupe de gérer une potentielle erreur
func (c *MainController) SaveFile(doc []byte, filename string) string {
	docPath, err := filepath.Abs(filepath.Join(LocalFolder, filename))
	if err != nil {
		c.ShowError(err)
		return ""
	}
	err = ioutil.WriteFile(docPath, doc, 0666)
	if err != nil {
		c.ShowError(err)
		return ""
	}
	return docPath
}