github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/server/core/datamodel/io.go

package datamodel

import (
	"compress/gzip"
	"encoding/json"
	"io"
	"log"
	"os"

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

// ----------------------------- JSON -----------------------------

// MarshalBaseLocale dumps la base en JSON, avec indentation
func MarshalBaseLocale(b *BaseLocale, out io.Writer) error {
	enc := json.NewEncoder(out)
	enc.SetIndent(" ", "  ")
	enc.SetEscapeHTML(false)
	err := enc.Encode(b)
	return err
}

// MarshalCompress marshal et compresse, sans indentation
func (b *BaseLocale) MarshalCompress(out io.Writer) error {
	return marshalCompress(b, out)
}

func marshalCompress(v interface{}, out io.Writer) error {
	gzOut := gzip.NewWriter(out)

	enc := json.NewEncoder(gzOut)
	enc.SetEscapeHTML(false)

	err := enc.Encode(v)
	if err != nil {
		return err
	}
	err = gzOut.Close()
	return err
}

func UnMarshalBaseLocale(in io.Reader) (BaseLocale, error) {
	dec := json.NewDecoder(in)
	var b BaseLocale
	err := dec.Decode(&b)
	return b, err
}

func DecompressUnMarshalBaseLocale(in io.Reader) (BaseLocale, error) {
	gzIn, err := gzip.NewReader(in)
	if err != nil {
		return BaseLocale{}, err
	}
	defer gzIn.Close()

	dec := json.NewDecoder(gzIn)
	var b BaseLocale
	err = dec.Decode(&b)
	return b, err
}

// -------------------------------- SQL -------------------------------

// a garder synchronisé
func loadLinksById(db rd.DB, items map[string][]int64) (out RawLinks, err error) {
	out.EquipierContraintes, err = rd.SelectEquipierContraintesByIdEquipiers(db, items["EquipierContraintes"]...)
	if err != nil {
		return out, err
	}
	out.GroupeParticipants, err = rd.SelectGroupeParticipantsByIdParticipants(db, items["ParticipantGroupe"]...)
	if err != nil {
		return out, err
	}
	out.ParticipantEquipiers, err = rd.SelectParticipantEquipiersByIdParticipants(db, items["ParticipantEquipier"]...)
	if err != nil {
		return out, err
	}
	out.GroupeContraintes, err = rd.SelectGroupeContraintesByIdGroupes(db, items["GroupeContraintes"]...)
	if err != nil {
		return out, err
	}
	out.CampContraintes, err = rd.SelectCampContraintesByIdCamps(db, items["CampContraintes"]...)
	if err != nil {
		return out, err
	}
	out.DocumentPersonnes, err = rd.SelectDocumentPersonnesByIdDocuments(db, items["DocumentPersonnes"]...)
	if err != nil {
		return out, err
	}
	out.DocumentAides, err = rd.SelectDocumentAidesByIdDocuments(db, items["DocumentAides"]...)
	if err != nil {
		return out, err
	}
	out.DocumentCamps, err = rd.SelectDocumentCampsByIdDocuments(db, items["DocumentCamps"]...)
	if err != nil {
		return out, err
	}
	out.MessageDocuments, err = rd.SelectMessageDocumentsByIdMessages(db, items["MessageDocuments"]...)
	if err != nil {
		return out, err
	}
	out.MessageSondages, err = rd.SelectMessageSondagesByIdMessages(db, items["MessageSondages"]...)
	if err != nil {
		return out, err
	}
	out.MessagePlaceliberes, err = rd.SelectMessagePlaceliberesByIdMessages(db, items["MessagePlaceliberes"]...)
	if err != nil {
		return out, err
	}
	out.MessageAttestations, err = rd.SelectMessageAttestationsByIdMessages(db, items["MessageAttestations"]...)
	if err != nil {
		return out, err
	}
	out.MessageMessages, err = rd.SelectMessageMessagesByIdMessages(db, items["MessageMessages"]...)
	if err != nil {
		return out, err
	}
	out.DonDonateurs, err = rd.SelectDonDonateursByIdDons(db, items["DonDonateurs"]...)
	if err != nil {
		return out, err
	}
	return out, nil
}

func (b *BaseLocale) ProcessRawLinks(rl RawLinks) {
	out := rd.Links{
		EquipierContraintes: rl.EquipierContraintes.ByIdEquipier(),
		ParticipantGroupe:   rl.GroupeParticipants.ByIdParticipant(),
		ParticipantEquipier: rl.ParticipantEquipiers.ByIdParticipant(),
		GroupeContraintes:   rl.GroupeContraintes.ByIdGroupe(),
		CampContraintes:     rl.CampContraintes.ByIdCamp(),
		DocumentPersonnes:   rl.DocumentPersonnes.ByIdDocument(),
		DocumentAides:       rl.DocumentAides.ByIdDocument(),
		DocumentCamps:       rl.DocumentCamps.ByIdDocument(),
		MessageDocuments:    rl.MessageDocuments.ByIdMessage(),
		MessageSondages:     rl.MessageSondages.ByIdMessage(),
		MessagePlaceliberes: rl.MessagePlaceliberes.ByIdMessage(),
		MessageAttestations: rl.MessageAttestations.ByIdMessage(),
		MessageMessages:     rl.MessageMessages.ByIdMessage(),
		DonDonateurs:        rl.DonDonateurs.ByIdDon(),
	}
	b.Links = out
}

// GetBase renvoie la base de developpement distante.
// Utile pour des tests
func GetBase(dev bool) *BaseLocale {
	logsDB := logs.DBProd
	if dev {
		logsDB = logs.DBDev
	}
	db, err := rd.ConnectDB(logsDB)
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()
	base, err := LoadRemoteBaseLocale(db)
	if err != nil {
		log.Fatal(err)
	}
	return base
}

// GetLocalDBDev renvoie la base locale.
// A utiliser depuis le dossier principal
func GetLocalDBDev() *BaseLocale {
	f, err := os.Open("local/DB.json")
	if err != nil {
		log.Fatal(err)
	}
	base, err := UnMarshalBaseLocale(f)
	if err != nil {
		log.Fatal(err)
	}
	return &base
}