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

package acvegestion

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"strconv"
	"time"

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

	"github.com/benoitkugler/goACVE/logs"
)

const (
	dateLayoutHelloAsso = "2006-01-02T15:04:05" // format personnalisé imposé par HelloAsso
	maxTry              = 3
	retryDelayMax       = 10 // en seconds
	typeDon             = "DONATION"

	resultsPerPage = 1000000
)

type paramsNotificationHelloAsso struct {
	// L’identifiant du paiement
	Id string `json:"id" form:"id"`
	// Action ID à requeter pour les infos complémentaires
	ActionId string `json:"action_id" form:"action_id"`
}

type actionHelloAsso struct {
	Id     string  `json:"id"`
	Type   string  `json:"type"`
	Amount float64 `json:"amount"`

	// IdCampaign string  `json:"id_campaign"`
	// IdOrganism string  `json:"id_organism"`
	// IdPayment  string  `json:"id_payment"`
	// DateString string  `json:"date"`
	// FirstName  string  `json:"first_name"`
	// LastName   string  `json:"last_name"`
	// Address    string  `json:"address"`
	// ZipCode    string  `json:"zip_code"`
	// City       string  `json:"city"`
	// Country    string  `json:"country"`
	// Email      string  `json:"email"`
	// Status     string  `json:"status"`
	// option_label ; custom_infos sont ignorés
}

type paiementHelloAsso struct {
	// L’identifiant du paiement
	Id string `json:"id"`
	// La date
	DateString string `json:"date"`
	// Le montant du paiement
	Amount float64 `json:"amount"`
	// Type de paiement
	Type string `json:"type"`
	// Mode de paiement
	Mean string `json:"mean"`

	PayerFirstName string `json:"payer_first_name"`
	PayerLastName  string `json:"payer_last_name"`
	PayerAddress   string `json:"payer_address"`
	PayerZipCode   string `json:"payer_zip_code"`
	PayerCity      string `json:"payer_city"`
	PayerCountry   string `json:"payer_country"`
	PayerEmail     string `json:"payer_email"`
	PayerSociety   string `json:"payer_society"`
	PayerIsSociety bool   `json:"payer_is_society"`

	// L’url du reçu
	UrlReceipt string            `json:"url_receipt" form:"url_receipt"`
	Actions    []actionHelloAsso `json:"actions"`
	// champs ignorés : url_tax_receipt, actions
}

// vérifie qu'au moins une action liée est un don
func (p paiementHelloAsso) isDon() bool {
	for _, ac := range p.Actions {
		if ac.Type == typeDon {
			return true
		}
	}
	return false
}

type pagination struct {
	Page          int `json:"page"`
	MaxPage       int `json:"max_page"`
	ResultPerPage int `json:"result_per_page"`
}

type paymentsResponse struct {
	Resources  []paiementHelloAsso `json:"resources,omitempty"`
	Pagination pagination          `json:"pagination,omitempty"`
}

// PingHelloAsso effectue une requête de test
// et renvoie l'éventuelle erreur.
func PingHelloAsso() error {
	url := "https://api.helloasso.com/v3/organizations.json?results_per_page=1000"
	_, err := requeteWithRetry(url, logs.HelloAsso)
	return err
}

func parseDateHelloAsso(d string) rd.Date {
	date, err := time.Parse(dateLayoutHelloAsso, d)
	if err != nil {
		date = time.Now()
	}
	return rd.Date(date)
}

func requeteWithRetry(url string, credences logs.CredencesHelloAsso) ([]byte, error) {
	toRetry := func() (resp *http.Response, delay time.Duration, err error) {
		req, err := http.NewRequest(http.MethodGet, url, nil)
		if err != nil {
			return nil, 0, fmt.Errorf("La requête vers HelloAsso est invalide : %s", err)
		}
		req.SetBasicAuth(credences.Id, credences.Key)
		resp, err = http.DefaultClient.Do(req)
		if err != nil {
			return nil, 0, fmt.Errorf("La requête vers HelloAsso a échoué : %s", err)
		}
		if resp.StatusCode == 503 { // retry
			retry := resp.Header.Get("Retry-After")
			secs, err := strconv.Atoi(retry)
			if err != nil || secs > retryDelayMax {
				secs = 2 // on essaye
			}
			resp.Body.Close() // on relache les éventuelles ressources
			return nil, time.Duration(secs) * time.Second, nil
		}
		return resp, 0, nil
	}

	nbRetry := 0
	var (
		resp  *http.Response
		delay time.Duration
		err   error
	)
	for nbRetry < maxTry {
		resp, delay, err = toRetry()
		if err != nil { // erreur innatendue :  on s'arrête
			return nil, err
		}
		if resp == nil { // on re-essaie
			nbRetry += 1
			time.Sleep(delay)
		} else {
			break
		}
	}
	defer resp.Body.Close()
	if resp.StatusCode != 200 {
		return nil, fmt.Errorf("La requête vers HelloAsso a reçu le code : %d", resp.StatusCode)
	}

	b, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return nil, fmt.Errorf("Réponse du serveur HelloAsso invalide (code %d) : %s", resp.StatusCode, err)
	}
	return b, nil
}

func newDonFromPayment(payment paiementHelloAsso) apiserver.DonDonateur {
	don := rd.Don{
		Valeur:        rd.Euros(payment.Amount),
		DateReception: parseDateHelloAsso(payment.DateString),
		ModePaiement:  rd.MPHelloasso,
		Details:       rd.String(payment.Id), // pourra être modifié
		Infos:         rd.InfoDon{IdPaiementHelloAsso: payment.Id},
	}
	// la plupart des paiements sont français,
	// et on utilise dans notre base plutôt le nom complet France
	if payment.PayerCountry == "FRA" {
		payment.PayerCountry = "France"
	}
	donateur := rd.BasePersonne{
		Prenom:     rd.String(payment.PayerFirstName),
		Nom:        rd.String(payment.PayerLastName),
		Adresse:    rd.String(payment.PayerAddress),
		CodePostal: rd.String(payment.PayerZipCode),
		Ville:      rd.String(payment.PayerCity),
		Pays:       rd.String(payment.PayerCountry),
		Mail:       rd.String(payment.PayerEmail),
	}
	return apiserver.DonDonateur{Don: don, Donateur: donateur}
}

func fetchAllPaiements(credences logs.CredencesHelloAsso) ([]paiementHelloAsso, error) {
	url := fmt.Sprintf("https://api.helloasso.com/v3/payments.json?results_per_page=%d", resultsPerPage)
	body, err := requeteWithRetry(url, logs.HelloAsso)
	if err != nil {
		return nil, err
	}
	var rep paymentsResponse
	if err := json.Unmarshal(body, &rep); err != nil {
		return nil, err
	}
	if rep.Pagination.MaxPage > 1 {
		// on doit recommencer pour les résultats manquants
		// cela ne devrait pas arriver en pratique, car `resultsPerPage`
		// est très grand
		return nil, fmt.Errorf("Le nombre de paiements à lire (%d) dépasse la quantité prévue (%d)", rep.Pagination.ResultPerPage*rep.Pagination.MaxPage, resultsPerPage)
	}
	return rep.Resources, nil
}

// cherche les nouveaux dons
func (ct Controller) importDonsHelloasso() ([]apiserver.DonDonateur, error) {
	ps, err := fetchAllPaiements(logs.HelloAsso)
	if err != nil {
		return nil, err
	}

	dons, err := rd.SelectAllDons(ct.DB)
	if err != nil {
		return nil, err
	}

	// on ne renvoie que les dons n'ayant pas encore été importés
	alreadyImported := map[string]bool{}
	for _, don := range dons {
		if don.ModePaiement == rd.MPHelloasso {
			alreadyImported[don.Infos.IdPaiementHelloAsso] = true
		}
	}
	var out []apiserver.DonDonateur
	for _, paiement := range ps {
		if alreadyImported[paiement.Id] {
			continue
		}
		// un paiement pourrait ne pas venir d'un don
		if !paiement.isDon() {
			continue
		}
		out = append(out, newDonFromPayment(paiement))
	}
	return out, nil
}

func (ct Controller) identifieDon(params apiserver.IdentifieDonIn) (out apiserver.IdentifieDonOut, err error) {
	tx, err := ct.DB.Begin()
	if err != nil {
		return out, err
	}

	// on commence par le donateur
	// la procédure de rattachement est simplifiée, car
	// le profil entrant est n'est pas un élément de la DB.
	if params.Rattache {
		pers, err := rd.SelectPersonne(tx, params.IdPersonneTarget)
		if err != nil {
			return out, shared.Rollback(tx, err)
		}
		pers.BasePersonne = params.Modifications
		out.Personne, err = pers.Update(tx)
	} else {
		pers := rd.Personne{BasePersonne: params.Modifications}
		out.Personne, err = pers.Insert(tx)
	}
	if err != nil {
		return out, shared.Rollback(tx, err)
	}

	// ... puis on crée le don
	out.Don, err = params.Don.Insert(tx)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}

	// ... puis le lien
	out.Donateur = rd.DonDonateur{
		IdDon:      out.Don.Id,
		IdPersonne: rd.NewOptionnalId(out.Personne.Id),
	}
	err = rd.InsertManyDonDonateurs(tx, out.Donateur)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}

	err = tx.Commit()
	return out, err
}