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

package recufiscal

import (
	"bytes"
	"fmt"
	"os/exec"
	"strconv"
	"strings"
	"time"

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

	"golang.org/x/text/encoding/unicode"

	"github.com/benoitkugler/num2words"

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

const (
	ModelePath    = "ressources/ModeleRecuFiscalEditable.pdf"
	valeurChecked = "Oui"

	fdfHeader = `%FDF-1.2
%,,oe"
1 0 obj
<<
/FDF << /Fields [`

	fdfFooter = `]
>>
>>
endobj
trailer
<<
/Root 1 0 R
>>
%%EOF`
)

var (
	// Indique l'identifiant des champs présents dans le modèle.
	// A synchroniser avec `MODELE_PATH`
	correspondancesChamps = struct {
		numero                          string
		infos                           infos
		categorie                       string
		utilitePublique                 utilitePublique
		donateur                        donateur
		don                             don
		articleLoi, formeDon, natureDon map[string]string
		modeDon                         map[rd.ModePaiment]string
		date                            date
	}{
		numero: "z1",
		infos: infos{
			nom:        "z2",
			adresse:    "z4",
			codePostal: "z5",
			ville:      "z5b",
			objectifL1: "z6",
			objectifL2: "z7",
		},
		categorie: "z9",
		utilitePublique: utilitePublique{
			jourDecret:   "d1",
			moisDecret:   "d2",
			anneeDecret:  "d3",
			jourJournal:  "d1b",
			moisJournal:  "d2b",
			anneeJournal: "d3b",
		},
		donateur: donateur{
			nom:        "z29",
			prenom:     "z30",
			adresse:    "z31",
			codePostal: "z32",
			ville:      "z33",
		},
		don: don{
			montantChiffre: "z34",
			montantLettre:  "z35",
			jourVersement:  "z36",
			moisVersement:  "z37",
			anneeVersement: "z38",
		},
		articleLoi: map[string]string{
			"200": "z39",
			"238": "z40",
			"885": "z41",
		},
		formeDon: map[string]string{
			"authentique": "z42",
			"seing":       "z43",
			"manuel":      "z44",
			"autres":      "z45",
		},
		natureDon: map[string]string{
			"numeraire": "z46",
			"titres":    "z47",
			"autres":    "z48",
		},
		modeDon: map[rd.ModePaiment]string{
			"esp":    "z49",
			"cheque": "z50",
			"vir":    "z51",
			"cb":     "z51",
			"ancv":   "z50",
		},
		date: date{
			jour:  "z52",
			mois:  "z53",
			annee: "z54",
		},
	}
)

// Définit les valeurs propres à l'ACVE
const (
	ArticleLoi = "200"
	FormeDon   = "manuel"
	NatureDon  = "numeraire"
)

var (
	Infos = infos{
		nom:        "ACVE",
		adresse:    "La Maison du Rocher",
		codePostal: "26160",
		ville:      "CHAMALOC",
		objectifL1: "Créer et gérer des séjours pour enfants, adolescents et adultes.",
		objectifL2: "Faire connaître, à travers des animations adaptées à l’âge des participants, les valeurs chrétiennes.",
	}
	UtilitePublique = utilitePublique{
		jourDecret:   "5",
		moisDecret:   "1",
		anneeDecret:  "1957",
		jourJournal:  "29",
		moisJournal:  "1",
		anneeJournal: "1957",
	}
)

type champPdf struct {
	id, valeur string
}

type utilitePublique struct {
	jourDecret   string
	moisDecret   string
	anneeDecret  string
	jourJournal  string
	moisJournal  string
	anneeJournal string
}

type infos struct {
	nom        string
	adresse    string
	codePostal string
	ville      string
	objectifL1 string
	objectifL2 string
}

type donateur struct {
	nom        string
	prenom     string
	adresse    string
	codePostal string
	ville      string
}

type don struct {
	montantChiffre string
	montantLettre  string
	jourVersement  string
	moisVersement  string
	anneeVersement string
}

type date struct {
	jour  string
	mois  string
	annee string
}

func champsACVE() []champPdf {
	champsInfos := correspondancesChamps.infos
	champUP := correspondancesChamps.utilitePublique
	return []champPdf{
		// ACVE
		{id: champsInfos.nom, valeur: Infos.nom},
		{id: champsInfos.adresse, valeur: Infos.adresse},
		{id: champsInfos.codePostal, valeur: Infos.codePostal},
		{id: champsInfos.ville, valeur: Infos.ville},
		{id: champsInfos.objectifL1, valeur: Infos.objectifL1},
		{id: champsInfos.objectifL2, valeur: Infos.objectifL2},

		// CATEGORIE ASSO
		{id: correspondancesChamps.categorie, valeur: valeurChecked},

		{id: champUP.anneeDecret, valeur: UtilitePublique.anneeDecret},
		{id: champUP.anneeJournal, valeur: UtilitePublique.anneeJournal},
		{id: champUP.jourDecret, valeur: UtilitePublique.jourDecret},
		{id: champUP.jourJournal, valeur: UtilitePublique.jourJournal},
		{id: champUP.moisDecret, valeur: UtilitePublique.moisDecret},
		{id: champUP.moisJournal, valeur: UtilitePublique.moisJournal},
	}
}

func champsDonateur(donateur donateur) []champPdf {
	champsDonateur := correspondancesChamps.donateur
	return []champPdf{
		{id: champsDonateur.nom, valeur: donateur.nom},
		{id: champsDonateur.prenom, valeur: donateur.prenom},
		{id: champsDonateur.adresse, valeur: donateur.adresse},
		{id: champsDonateur.codePostal, valeur: donateur.codePostal},
		{id: champsDonateur.ville, valeur: donateur.ville},
	}
}

// `don` représente une aggrégation de plusieurs dons.
func champsDon(don dm.RecuFiscal) []champPdf {
	champsDon := correspondancesChamps.don
	date := don.Date

	montantLettre := num2words.EurosToWords(float64(don.Montant))
	return []champPdf{
		{id: champsDon.montantChiffre, valeur: fmt.Sprintf("%.2f", don.Montant)},
		{id: champsDon.montantLettre, valeur: montantLettre},
		{id: champsDon.jourVersement, valeur: strconv.Itoa(date.Day())},
		{id: champsDon.moisVersement, valeur: strconv.Itoa(int(date.Month()))},
		{id: champsDon.anneeVersement, valeur: strconv.Itoa(date.Year())},
		{id: correspondancesChamps.modeDon[don.Mode], valeur: valeurChecked},
	}
}

func champsTypeDon() []champPdf {
	return []champPdf{
		{id: correspondancesChamps.articleLoi[ArticleLoi], valeur: valeurChecked},
		{id: correspondancesChamps.natureDon[NatureDon], valeur: valeurChecked},
		{id: correspondancesChamps.formeDon[FormeDon], valeur: valeurChecked},
	}
}

func champsDateEdition() []champPdf {
	corresDate := correspondancesChamps.date
	today := time.Now()
	return []champPdf{
		{id: corresDate.jour, valeur: strconv.Itoa(today.Day())},
		{id: corresDate.mois, valeur: strconv.Itoa(int(today.Month()))},
		{id: corresDate.annee, valeur: strconv.Itoa(today.Year())},
	}
}

func forgeFDF(form []champPdf) string {
	w := new(strings.Builder)

	// Write the fdf header.
	if _, err := fmt.Fprintln(w, fdfHeader); err != nil {
		return ""
	}

	encoder := unicode.UTF16(unicode.BigEndian, unicode.UseBOM).NewEncoder()

	// Write the form data.
	for _, champ := range form {
		utf16, _ := encoder.String(champ.valeur)
		if _, err := fmt.Fprintf(w, "<< /T (%s) /V (%v)>>\n", champ.id, utf16); err != nil {
			return ""
		}
	}

	// Write the fdf footer.
	if _, err := fmt.Fprintln(w, fdfFooter); err != nil {
		return ""
	}

	return w.String()
}

// ParamsRecuFiscal encode les informations nécessaire à l'émission d'un reçu fiscal.
// Dans le cas de plusieurs dons, `Montant` est le total des dons, et `Mode` est
// le mode commun.
type RecuFiscal struct {
	dm.RecuFiscal
	Donateur rd.Personne `json:"donateur,omitempty"`
}

// renvoie le numéro de reçu (unique par donateur / année)
func (r RecuFiscal) numero() string {
	n := time.Now()
	return fmt.Sprintf("%04d%02d", r.Donateur.Id, n.Year()%100)
}

// RempliPdf Crée un recu, à l'aide de pdftk, qui doit être installé.
func RempliPdf(params RecuFiscal) ([]byte, error) {
	champNum := champPdf{id: correspondancesChamps.numero, valeur: params.numero()}
	donateur := donateur{
		nom:        string(params.Donateur.Nom),
		prenom:     string(params.Donateur.Prenom),
		adresse:    string(params.Donateur.Adresse),
		codePostal: string(params.Donateur.CodePostal),
		ville:      string(params.Donateur.Ville),
	}
	fields := []champPdf{champNum}
	fields = append(fields, champsACVE()...)
	fields = append(fields, champsDonateur(donateur)...)
	fields = append(fields, champsDon(params.RecuFiscal)...)
	fields = append(fields, champsTypeDon()...)
	fields = append(fields, champsDateEdition()...)
	fdf := forgeFDF(fields)
	cmd := exec.Command("pdftk", ModelePath, "fill_form", "-", "output", "-")
	cmd.Stdin = strings.NewReader(fdf)
	errOut := new(bytes.Buffer)
	cmd.Stderr = errOut
	pdfBytes, err := cmd.Output()
	if err != nil {
		return nil, fmt.Errorf("Création du reçu impossible : %s : %s", err, errOut.String())
	}
	return pdfBytes, nil
}