github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/client/GUI/common/documents.go

package common

import (
	"errors"
	"fmt"
	"path/filepath"
	"strings"
	"sync"

	dm "github.com/benoitkugler/goACVE/server/core/datamodel"
	rd "github.com/benoitkugler/goACVE/server/core/rawdata"

	"github.com/therecipe/qt/core"

	"github.com/therecipe/qt/gui"

	"github.com/benoitkugler/goACVE/client/GUI/lists"

	"github.com/benoitkugler/goACVE/client/GUI/basic"

	"github.com/benoitkugler/goACVE/client/controllers"

	"github.com/therecipe/qt/widgets"
)

type sharedMiniatures struct {
	sync.RWMutex
	d map[int64][]byte
}

func newSharedMiniatures() *sharedMiniatures {
	var s sharedMiniatures
	s.d = make(map[int64][]byte)
	return &s
}

func (s *sharedMiniatures) Keys() map[int64]bool {
	s.RLock()
	defer s.RUnlock()
	out := make(map[int64]bool, len(s.d))
	for i := range s.d {
		out[i] = true
	}
	return out
}

func (s *sharedMiniatures) Read(i int64) []byte {
	s.RLock()
	defer s.RUnlock()
	b := s.d[i]
	return b
}

func (s *sharedMiniatures) WriteMany(min map[int64][]byte) {
	s.Lock()
	defer s.Unlock()
	for id, m := range min {
		s.d[id] = m
	}
}

type Documents struct {
	*widgets.QDialog
	forAide bool

	main       *controllers.MainController
	editable   bool
	miniatures *sharedMiniatures
	documents  lists.Table
	preview    *widgets.QLabel

	refresh          *widgets.QToolButton
	upload, download *widgets.QPushButton
}

func NewDocuments(main *controllers.MainController, editable bool, forAide bool) *Documents {
	d := Documents{QDialog: basic.Dialog2("Documents"), main: main,
		editable: editable, forAide: forAide}
	d.miniatures = newSharedMiniatures()
	d.preview = basic.Label("<i>Aucune miniature.</i>")
	d.preview.SetMinimumWidth(200)
	d.preview.SetAlignment(core.Qt__AlignCenter)

	d.refresh = widgets.NewQToolButton(nil)
	d.refresh.SetIcon(basic.Icons.Refresh)
	d.refresh.SetToolTip("Rafraichir la miniature")
	d.refresh.ConnectClicked(func(_ bool) {
		if item, ok := d.documents.CurrentData(); ok {
			d.refreshMiniature(item.Id.Int64())
		}
	})
	d.refresh.SetObjectName(basic.ONAction)

	d.upload = basic.Button("Remplacer")
	d.upload.ConnectClicked(d.remplaceDocument)
	d.upload.SetObjectName(basic.ONAction)

	d.download = basic.Button("Télécharger")
	d.download.ConnectClicked(d.downloadDocument)
	d.download.SetObjectName(basic.ONAction)

	d.refresh.SetEnabled(false)
	d.upload.SetEnabled(false)
	d.download.SetEnabled(false)

	newDoc := basic.Button("Ajouter")
	newDoc.SetObjectName(basic.ONAdd)
	newDoc.ConnectClicked(d.ajouteDocument)
	rightHeader := widgets.NewQHBoxLayout()
	rightHeader.AddWidget(newDoc, 1, core.Qt__AlignRight)
	d.documents = lists.Table{
		Liste: lists.Liste{
			Headers: []rd.Header{
				{Field: dm.DocumentNomPrenom, Label: "Lié à"},
				{Field: dm.DocumentCategorie, Label: "Catégorie"},
				{Field: dm.DocumentNomClient, Label: "Fichier"},
				{Field: dm.DocumentTaille, Label: "Taille"},
				{Field: dm.DocumentDescription, Label: "Description"},
				{Field: dm.DocumentDateHeureModif, Label: "Modifié le"},
			},
			Placeholder: "Aucun document.",
			MinHeight:   400,
			MinWidth:    950,
			OnSearch: func(pattern string) {
				list := main.Base.GetAllDocuments(forAide)
				if pattern != "" {
					list = dm.RechercheDetaillee(list, pattern, d.documents.Liste.Headers)
				}
				d.documents.Model().SetData(list)
				d.completeMiniatures()
			},
			OnSort: func(field rd.Field, reverse bool) {
				data := d.documents.Model().GetData()
				dm.SortBy(data, field, reverse)
				d.documents.Model().SetData(data)
			},
			Title:       "Documents",
			RightHeader: rightHeader,
		},
	}
	if editable {
		d.documents.OnDelete = func(acces rd.Item, _ int) {
			d.supprimeDocument(acces.Id.Int64())
		}
	}
	d.documents.OnClick = func(acces rd.Item, _ int) {
		d.activateItem(acces.Id)
	}
	d.documents.Init()
	d.documents.HorizontalHeader().SetMinimumSectionSize(200)

	d.documents.ConnectDataChanged(func() {
		d.refresh.SetEnabled(false)
		d.upload.SetEnabled(false)
		d.download.SetEnabled(false)
		d.preview.SetText("<i>Aucune miniature.</i>")
	})

	lay := widgets.NewQGridLayout(d)
	lay.AddWidget3(d.documents, 0, 0, 3, 1, 0)
	lay.AddWidget2(basic.Label("Aperçu"), 0, 1, 0)
	lay.AddWidget2(d.refresh, 0, 2, core.Qt__AlignRight)
	lay.AddWidget3(d.preview, 1, 1, 1, 2, 0)
	lay.AddWidget2(d.upload, 2, 1, core.Qt__AlignLeft)
	lay.AddWidget2(d.download, 2, 2, core.Qt__AlignRight)

	sBar := widgets.NewQStatusBar(nil)
	MainWindow.StatusBar().ConnectMessageChanged(func(message string) {
		sBar.ShowMessage(message, 0)
		sBar.Repaint()
	})
	lay.AddWidget3(sBar, 3, 0, 1, 3, 0)
	d.SetModal(true)
	return &d
}

func (d Documents) activateItem(id rd.IId) {
	d.refresh.SetEnabled(true)
	d.upload.SetEnabled(true)
	d.download.SetEnabled(true)
	d.showMiniature(id.Int64())
}

// RenderDocuments calcule les documents à afficher,
// met à jour l'affichage, et lance le chargement des miniatures manquantes
func (d Documents) RenderDocuments() {
	var liste rd.Table
	// aides / personnes ; target courante
	if d.forAide {
		ct := d.main.Controllers.Aides
		if idAide := ct.Etat.AideCurrent; idAide != nil {
			liste = ct.Base.NewAide(idAide.Int64()).GetDocuments()
		} else {
			liste = ct.Base.GetAllDocuments(true)
		}
	} else {
		ct := d.main.Controllers.Personnes
		if idPersonne, ok := ct.Etat.ItemCurrent.(rd.IdPersonne); ok {
			docs := ct.Base.NewPersonne(idPersonne.Int64()).GetDocuments(nil)
			liste = dm.DocumentsPersonnesToAcces(docs)
		} else {
			liste = ct.Base.GetAllDocuments(false)
		}
	}
	currentItem, has := d.documents.CurrentData()
	d.documents.Model().SetData(liste)
	if has {
		d.documents.SelectRow(currentItem.Id)
		d.activateItem(currentItem.Id)
	}
	d.completeMiniatures()
}

func (d Documents) showMiniature(id int64) {
	im := d.miniatures.Read(id)
	size := len(im)
	if size == 0 {
		d.preview.SetText("<i>Aucune miniature</i>")
		return
	}
	image := gui.QImage_FromData(im, size, "")
	d.preview.SetPixmap(gui.NewQPixmap().FromImage(image, 0))
}

func (d Documents) completeMiniatures() {
	var needed rd.Ids
	already := d.miniatures.Keys()
	for _, doc := range d.documents.Model().GetData() {
		id := doc.Id.Int64()
		if !already[id] {
			needed = append(needed, id)
		}
	}
	go d.loadMiniatures(needed)
}

func (d Documents) loadMiniatures(ids rd.Ids) {
	if len(ids) == 0 {
		return
	}
	d.main.ShowStandard("Chargement des miniatures...", true)
	out, err := controllers.LoadMiniatures(ids)
	if err != nil {
		d.main.ShowStandard(fmt.Sprintf("Erreur pendant le chargement des miniatures : %s", err), false)
		return
	}
	d.miniatures.WriteMany(out)
	d.main.ShowStandard("Miniatures téléchargées.", false)
}

func (d Documents) supprimeDocument(idDoc int64) {
	doc := d.main.Base.Documents[idDoc]
	dial := basic.Dialog("Confirmation")
	dial.Layout().AddWidget(basic.Label(fmt.Sprintf("Confirmez-vous la <b>suppression</b> du document <i>%s</i> (%d KB) ? <br/> Attention, cette opération est irréversible.", doc.NomClient, doc.Taille/1000)))
	valid := basic.Button("Supprimer")
	valid.SetObjectName(basic.ONDelete)
	valid.ConnectClicked(func(_ bool) {
		dial.Accept()
	})
	dial.Layout().AddWidget(valid)
	if dial.Exec() == 0 {
		d.main.ShowStandard("Suppression annulée", false)
		return
	}
	d.SetEnabled(false)
	d.main.SupprimeDocument(idDoc)
	d.RenderDocuments()
	d.SetEnabled(true)
}

func (d *Documents) ajouteDocument(_ bool) {
	docPath := SelectFile()
	if docPath == "" {
		d.main.ShowStandard("Aucun fichier choisir, ajout annulé.", false)
		return
	}

	type ficheDoc interface {
		Fiche
		SetData(document rd.Document, targetDocument rd.TargetDocument)
		GetData() (rd.Document, rd.TargetDocument)
	}

	var (
		fi     ficheDoc
		target rd.TargetDocument
	)

	if d.forAide {
		fi = NewFicheDocumentAide(d.main.Base, d.editable)
		if pc := d.main.Controllers.Aides.Etat.AideCurrent; pc != nil {
			target = rd.DocumentAide{IdAide: pc.Int64()}
		}
	} else {
		fi = NewFicheDocumentPersonne(d.main.Base, d.editable)
		if pc, ok := d.main.Controllers.Personnes.Etat.ItemCurrent.(rd.IdPersonne); ok {
			target = rd.DocumentPersonne{IdPersonne: pc.Int64()}
		}
	}

	doc := rd.Document{NomClient: rd.String(filepath.Base(docPath))}
	fi.SetData(doc, target)
	det := NewDetails(fi, d.editable)
	if det.Exec() == 0 {
		d.main.ShowStandard("Ajout annulé.", false)
		return
	}
	doc, target = fi.GetData()

	d.SetEnabled(false)
	d.Repaint()
	mon := NewMonitorDownload("Téléversement vers le serveur...")
	basic.Delay(func() {
		d.main.CreeUploadDocument(docPath, doc, target, mon.Monitor)
		mon.Close()
		d.SetEnabled(true)
		d.RenderDocuments()
	})
}

func (d *Documents) remplaceDocument(_ bool) {
	item, ok := d.documents.CurrentData()
	if !ok {
		d.main.ShowError(errors.New("Veuillez choisir un document."))
		return
	}
	doc := d.main.Base.Documents[item.Id.Int64()]
	docPath := SelectFile()
	if docPath == "" {
		d.main.ShowStandard("Aucun fichier choisit, remplacement annulé.", false)
		return
	}
	d.SetEnabled(false)
	d.Repaint()
	mon := NewMonitorDownload("Téléversement vers le serveur...")
	basic.Delay(func() {
		out := d.main.UploadDocument(docPath, doc.Id, mon.Monitor)
		mon.Close()
		d.SetEnabled(true)
		if out != nil {
			d.refreshMiniature(out.Id)
		}
		d.RenderDocuments()
	})
}

func (d *Documents) downloadDocument(_ bool) {
	item, ok := d.documents.CurrentData()
	if !ok {
		d.main.ShowError(errors.New("Veuillez choisir un document."))
		return
	}
	mon := NewMonitorDownload("Téléchargement du document...")
	basic.Delay(func() {
		path := d.main.DownloadDocument(item.Id.Int64(), mon.Monitor)
		mon.Close()
		basic.ShowFile(path)
	})
}

func (d *Documents) refreshMiniature(idDoc int64) {
	d.loadMiniatures([]int64{idDoc})
	sizeMin := len(d.miniatures.Read(idDoc))
	msg := fmt.Sprintf("Miniature téléchargée (%d KB)", sizeMin/1000)
	if sizeMin == 0 {
		msg = "Miniature indisponible"
	}
	d.main.ShowStandard(msg, false)
	d.showMiniature(idDoc)
}

var acceptedFiles = []string{"application/pdf", "image/jpeg", "image/png"}

func SelectFile() string {
	var patterns []string
	db := core.NewQMimeDatabase2()
	for _, ty := range acceptedFiles {
		mime := db.MimeTypeForName(ty)
		if mime.IsValid() {
			patterns = append(patterns, strings.Join(mime.GlobPatterns(), " "))
		}
	}
	nameFiler := "Acceptés (" + strings.Join(patterns, " ") + ")"
	return widgets.QFileDialog_GetOpenFileName(nil, "Sélectionner un fichier", "", nameFiler, "", 0)
}