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

package table

import (
	"bytes"
	"encoding/json"
	"fmt"
	"path/filepath"
	"strconv"

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

	"github.com/360EntSecGroup-Skylar/excelize"
)

// attributs à appliquer sur une case
// doit pouvoir être une clé de dictionnaire
type style struct {
	color                        string
	bold, italic, withLeftBorder bool
	euros                        bool
}

type fill struct {
	Type    string    `json:"type"`
	Color   [1]string `json:"color"`
	Pattern int       `json:"pattern"`
}
type font struct {
	Bold   bool `json:"bold"`
	Italic bool `json:"italic"`
}
type border [1]struct {
	Type  string `json:"type"`
	Color string `json:"color"`
	Style int    `json:"style"`
}

// enregistre le style sur excelize
// ne devrait être appelé qu'une seule fois par style
func (s style) register(b builder) (int, error) {
	styles := map[string]interface{}{}
	if s.color != "" {
		styles["fill"] = fill{Type: "pattern", Color: [1]string{s.color}, Pattern: 1}
	}
	styles["font"] = font{Bold: s.bold, Italic: s.italic}
	if s.withLeftBorder {
		styles["border"] = border{{Type: "left", Color: "000000", Style: 6}}
	}
	if s.euros {
		styles["number_format"] = 219
	}
	format, err := json.Marshal(styles)
	if err != nil {
		return 0, err
	}
	return b.NewStyle(string(format))
}

func stringWidth(s string, bold bool) float64 {
	c := 1.1
	if bold {
		c = 1.2
	}
	return 2 + c*float64(len([]rune(s)))
}

func findColWidth(header rd.Header, liste rd.Table) float64 {
	maxWidth := stringWidth(header.Label, true)
	for _, row := range liste {
		if width := stringWidth(row.Fields.Data(header.Field).String(), false); width > maxWidth {
			maxWidth = width
		}
	}
	return maxWidth
}

// dirige la création du fichier
type builder struct {
	*excelize.File

	styles map[[2]int]style // (row, col) -> style
}

func newBuilder() builder {
	return builder{File: excelize.NewFile(), styles: map[[2]int]style{}}
}

func (b builder) setCell(row, col int, value string) error {
	cell, err := excelize.CoordinatesToCellName(col, row)
	if err != nil {
		return err
	}
	return b.SetCellStr("Sheet1", cell, value)
}

// enregistre le style pour la case donnée
// le style est effectivement appliquer via la méthode `applyStyles`
func (b builder) setStyle(color rd.Color, bold, italic, withLeftBorder, euros bool, row, col int) {
	s := style{bold: bold, italic: italic, withLeftBorder: withLeftBorder, euros: euros}
	if color != nil {
		s.color = color.Hex()
	}
	b.styles[[2]int{row, col}] = s
}

func (b builder) applyStyles() error {
	// aggrège les styles
	m := map[style]int{}
	for _, v := range b.styles {
		m[v] = 0
	}
	// récupère l'ID excelize
	for s := range m {
		id, err := s.register(b)
		if err != nil {
			return err
		}
		m[s] = id
	}
	// parcourt le fichier pour appliquer les styles
	for cell, style := range b.styles {
		row, col := cell[0], cell[1]
		cellName, err := excelize.CoordinatesToCellName(col, row)
		if err != nil {
			return err
		}
		if err = b.SetCellStyle("Sheet1", cellName, cellName, m[style]); err != nil {
			return err
		}
	}
	return nil
}

type Total struct {
	label string
	value string
}

func (b builder) drawItems(headers []rd.Header, liste rd.Table, startingRow int, showLineNumbers, showColors bool, colLeftBorder int) error {
	var colOffset int // pour les numéros de lignes
	if showLineNumbers {
		colOffset = 1
	}

	for row, data := range liste {
		currentRow := row + startingRow
		if showLineNumbers {
			if err := b.setCell(currentRow, 1, strconv.Itoa(row+1)); err != nil {
				return err
			}
		}
		for col, field := range headers {
			currentCol := col + 1 + colOffset
			var color rd.Color
			if showColors {
				color = data.BackgroundColor(field.Field)
			}

			cellData := data.Fields.Data(field.Field)
			_, isEuros := cellData.(rd.Euros) // applique le format euros
			b.setStyle(color, data.Bolds[field.Field], false,
				colLeftBorder == currentCol, isEuros, currentRow, currentCol)

			if err := b.setCell(currentRow, currentCol, cellData.String()); err != nil {
				return err
			}
		}
	}
	return nil
}

// if `colLeftBorder == -1`, aucune ligne verticale supplémentaire n'est tracée
func renderListe(headers []rd.Header, liste rd.Table, totals []Total, showLineNumbers, showColors bool, colLeftBorder int) (*excelize.File, error) {
	b := newBuilder()
	var colOffset int // pour les numéros de lignes
	if showLineNumbers {
		colOffset = 1
	}

	// headers
	for col, field := range headers {
		if err := b.setCell(1, col+1+colOffset, field.Label); err != nil {
			return nil, err
		}
		b.setStyle(nil, true, false, false, false, 1, col+1+colOffset)
		colLetter, err := excelize.ColumnNumberToName(col + 1 + colOffset)
		if err != nil {
			return nil, err
		}
		colWidth := findColWidth(field, liste)
		if err := b.SetColWidth("Sheet1", colLetter, colLetter, colWidth); err != nil {
			return nil, err
		}
	}

	// datas
	if err := b.drawItems(headers, liste, 2, showLineNumbers, showColors, colLeftBorder); err != nil {
		return nil, err
	}

	// pour une ligne de totaux
	totalRow := len(liste) + 3
	for index, total := range totals {
		if err := b.setCell(totalRow, 2*index+1+colOffset, total.label); err != nil {
			return nil, err
		}
		b.setStyle(nil, false, true, false, false, totalRow, 2*index+1+colOffset)
		if err := b.setCell(totalRow, 2*index+2+colOffset, total.value); err != nil {
			return nil, err
		}
		b.setStyle(nil, true, false, false, false, totalRow, 2*index+2+colOffset)
	}

	// applique les styles
	if err := b.applyStyles(); err != nil {
		return nil, err
	}

	return b.File, nil
}

func save(f *excelize.File, directory, filename string) (string, error) {
	path, err := filepath.Abs(filepath.Join(directory, filename))
	if err != nil {
		return "", err
	}
	err = f.SaveAs(path)
	if err != nil {
		return "", err
	}
	return path, nil
}

// ExportExcel enregistre un fichier excel basique.
func ExportExcel(headers []rd.Header, liste rd.Table, directory string) (string, error) {
	f, err := renderListe(headers, liste, nil, false, true, -1)
	if err != nil {
		return "", err
	}
	return save(f, directory, "export.xlsx")
}

func GenereListeAides(headers []rd.Header, liste rd.Table, directory string) (string, error) {
	f, err := renderListe(headers, liste, nil, false, true, -1)
	if err != nil {
		return "", err
	}
	return save(f, directory, "liste_aides.xlsx")
}

func GenereListeEquipe(headers []rd.Header, liste rd.Table, showColors bool) (*bytes.Buffer, error) {
	f, err := renderListe(headers, liste, nil, false, showColors, -1)
	if err != nil {
		return nil, err
	}
	return f.WriteToBuffer()
}

func EnregistreListePaiements(headers []rd.Header, liste rd.Table, total rd.Euros, directory string) (string, error) {
	totals := []Total{
		{"Total :", total.String()},
	}
	f, err := renderListe(headers, liste, totals, true, true, -1)
	if err != nil {
		return "", err
	}
	return save(f, directory, "liste_paiements.xlsx")
}

// EnregistreSuiviFinancierCamp enregistre un tableau des participants avec l'état de leur facture
func EnregistreSuiviFinancierCamp(headers []rd.Header, liste rd.Table, totalDemande,
	totalAides rd.Euros, nomCamp, directory string) (string, error) {
	totals := []Total{
		{"Total demandé:", totalDemande.String()},
		{"Total aides:", totalAides.String()},
	}
	f, err := renderListe(headers, liste, totals, false, true, -1)
	if err != nil {
		return "", err
	}
	return save(f, directory, fmt.Sprintf("suivi_financier_%s.xlsx", nomCamp))
}

// GenereSuiviFinancierCamp renvoie un tableau des participants avec l'état de leur facture
func GenereSuiviFinancierCamp(headers []rd.Header, liste rd.Table, totalDemande,
	totalAides rd.Euros) (*bytes.Buffer, error) {
	totals := []Total{
		{"Total demandé:", totalDemande.String()},
		{"Total aides:", totalAides.String()},
	}
	f, err := renderListe(headers, liste, totals, false, true, -1)
	if err != nil {
		return nil, err
	}
	return f.WriteToBuffer()
}

func genereListeParticipants(headersParticipant, headersResponsable []rd.Header, inscrits, attente rd.Table, showColors bool) (*excelize.File, error) {
	headers := append(headersParticipant, headersResponsable...)
	colLine := len(headersParticipant) + 1

	liste := append(append(inscrits, rd.Item{}, rd.Item{}), attente...) // saut de lignes entre inscrits et attente

	f, err := renderListe(headers, liste, nil, false, showColors, colLine)
	if err != nil {
		return nil, err
	}
	return f, nil
}

func EnregistreListeParticipants(headersParticipant, headersResponsable []rd.Header, inscrits, attente rd.Table, showColors bool,
	nomCamp, directory string) (filepath string, err error) {
	f, err := genereListeParticipants(headersParticipant, headersResponsable, inscrits, attente, showColors)
	if err != nil {
		return "", err
	}
	return save(f, directory, fmt.Sprintf("liste_%s.xlsx", nomCamp))
}

func GenereListeParticipants(headersParticipant, headersResponsable []rd.Header, inscrits, attente rd.Table, showColors bool) (*bytes.Buffer, error) {
	f, err := genereListeParticipants(headersParticipant, headersResponsable, inscrits, attente, showColors)
	if err != nil {
		return nil, err
	}
	return f.WriteToBuffer()
}

func EnregistreBilanCamps(headers []rd.Header, camps rd.Table, directory string) (string, error) {
	f, err := renderListe(headers, camps, nil, false, true, -1)
	if err != nil {
		return "", err
	}
	return save(f, directory, "bilan_camps.xlsx")
}

func EnregistreDons(headers []rd.Header, dons rd.Table, total rd.Euros, directory string) (string, error) {
	totals := []Total{
		{label: "Total", value: total.String()},
	}
	f, err := renderListe(headers, dons, totals, true, false, -1)
	if err != nil {
		return "", err
	}
	return save(f, directory, "dons.xlsx")
}