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

// DO NOT EDIT -- auto-generated from rawadata.go
package datamodel

import (
	"encoding/json"
	"hash/crc32"

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

// BaseLocale stocke en mémoire vive toutes les informations nécessaires,
// sous forme brute.
type BaseLocale struct {
	Personnes          rd.Personnes
	Camps              rd.Camps
	Groupes            rd.Groupes
	Sondages           rd.Sondages
	Participants       rd.Participants
	Equipiers          rd.Equipiers
	Participantsimples rd.Participantsimples
	Structureaides     rd.Structureaides
	Aides              rd.Aides
	Organismes         rd.Organismes
	Dons               rd.Dons
	Contraintes        rd.Contraintes
	Documents          rd.Documents
	Paiements          rd.Paiements
	Factures           rd.Factures
	Messages           rd.Messages

	rd.Links
}

type RawLinks struct {
	GroupeParticipants   rd.GroupeParticipants
	GroupeEquipiers      rd.GroupeEquipiers
	ParticipantEquipiers rd.ParticipantEquipiers
	DonDonateurs         rd.DonDonateurs
	EquipierContraintes  rd.EquipierContraintes
	CampContraintes      rd.CampContraintes
	GroupeContraintes    rd.GroupeContraintes
	DocumentCamps        rd.DocumentCamps
	DocumentPersonnes    rd.DocumentPersonnes
	DocumentAides        rd.DocumentAides
	MessageDocuments     rd.MessageDocuments
	MessageSondages      rd.MessageSondages
	MessagePlaceliberes  rd.MessagePlaceliberes
	MessageAttestations  rd.MessageAttestations
	MessageMessages      rd.MessageMessages
}

func LoadRemoteBaseLocale(db rd.DB) (base *BaseLocale, err error) {
	base = new(BaseLocale)
	var rl RawLinks

	base.Personnes, err = rd.SelectAllPersonnes(db)
	if err != nil {
		return nil, err
	}

	base.Camps, err = rd.SelectAllCamps(db)
	if err != nil {
		return nil, err
	}

	base.Groupes, err = rd.SelectAllGroupes(db)
	if err != nil {
		return nil, err
	}

	base.Sondages, err = rd.SelectAllSondages(db)
	if err != nil {
		return nil, err
	}

	base.Participants, err = rd.SelectAllParticipants(db)
	if err != nil {
		return nil, err
	}

	base.Equipiers, err = rd.SelectAllEquipiers(db)
	if err != nil {
		return nil, err
	}

	base.Participantsimples, err = rd.SelectAllParticipantsimples(db)
	if err != nil {
		return nil, err
	}

	base.Structureaides, err = rd.SelectAllStructureaides(db)
	if err != nil {
		return nil, err
	}

	base.Aides, err = rd.SelectAllAides(db)
	if err != nil {
		return nil, err
	}

	base.Organismes, err = rd.SelectAllOrganismes(db)
	if err != nil {
		return nil, err
	}

	base.Dons, err = rd.SelectAllDons(db)
	if err != nil {
		return nil, err
	}

	base.Contraintes, err = rd.SelectAllContraintes(db)
	if err != nil {
		return nil, err
	}

	base.Documents, err = rd.SelectAllDocuments(db)
	if err != nil {
		return nil, err
	}

	base.Paiements, err = rd.SelectAllPaiements(db)
	if err != nil {
		return nil, err
	}

	base.Factures, err = rd.SelectAllFactures(db)
	if err != nil {
		return nil, err
	}

	base.Messages, err = rd.SelectAllMessages(db)
	if err != nil {
		return nil, err
	}

	rl.GroupeParticipants, err = rd.SelectAllGroupeParticipants(db)
	if err != nil {
		return nil, err
	}

	rl.GroupeEquipiers, err = rd.SelectAllGroupeEquipiers(db)
	if err != nil {
		return nil, err
	}

	rl.ParticipantEquipiers, err = rd.SelectAllParticipantEquipiers(db)
	if err != nil {
		return nil, err
	}

	rl.DonDonateurs, err = rd.SelectAllDonDonateurs(db)
	if err != nil {
		return nil, err
	}

	rl.EquipierContraintes, err = rd.SelectAllEquipierContraintes(db)
	if err != nil {
		return nil, err
	}

	rl.CampContraintes, err = rd.SelectAllCampContraintes(db)
	if err != nil {
		return nil, err
	}

	rl.GroupeContraintes, err = rd.SelectAllGroupeContraintes(db)
	if err != nil {
		return nil, err
	}

	rl.DocumentCamps, err = rd.SelectAllDocumentCamps(db)
	if err != nil {
		return nil, err
	}

	rl.DocumentPersonnes, err = rd.SelectAllDocumentPersonnes(db)
	if err != nil {
		return nil, err
	}

	rl.DocumentAides, err = rd.SelectAllDocumentAides(db)
	if err != nil {
		return nil, err
	}

	rl.MessageDocuments, err = rd.SelectAllMessageDocuments(db)
	if err != nil {
		return nil, err
	}

	rl.MessageSondages, err = rd.SelectAllMessageSondages(db)
	if err != nil {
		return nil, err
	}

	rl.MessagePlaceliberes, err = rd.SelectAllMessagePlaceliberes(db)
	if err != nil {
		return nil, err
	}

	rl.MessageAttestations, err = rd.SelectAllMessageAttestations(db)
	if err != nil {
		return nil, err
	}

	rl.MessageMessages, err = rd.SelectAllMessageMessages(db)
	if err != nil {
		return nil, err
	}

	base.ProcessRawLinks(rl)

	return base, nil
}

func LoadRemoteBaseLocalePartiel(db rd.DB, items map[string][]int64) (base *BaseLocale, err error) {
	base = new(BaseLocale)

	base.Personnes, err = rd.SelectPersonnes(db, items["Personnes"]...)
	if err != nil {
		return nil, err
	}

	base.Camps, err = rd.SelectCamps(db, items["Camps"]...)
	if err != nil {
		return nil, err
	}

	base.Groupes, err = rd.SelectGroupes(db, items["Groupes"]...)
	if err != nil {
		return nil, err
	}

	base.Sondages, err = rd.SelectSondages(db, items["Sondages"]...)
	if err != nil {
		return nil, err
	}

	base.Participants, err = rd.SelectParticipants(db, items["Participants"]...)
	if err != nil {
		return nil, err
	}

	base.Equipiers, err = rd.SelectEquipiers(db, items["Equipiers"]...)
	if err != nil {
		return nil, err
	}

	base.Participantsimples, err = rd.SelectParticipantsimples(db, items["Participantsimples"]...)
	if err != nil {
		return nil, err
	}

	base.Structureaides, err = rd.SelectStructureaides(db, items["Structureaides"]...)
	if err != nil {
		return nil, err
	}

	base.Aides, err = rd.SelectAides(db, items["Aides"]...)
	if err != nil {
		return nil, err
	}

	base.Organismes, err = rd.SelectOrganismes(db, items["Organismes"]...)
	if err != nil {
		return nil, err
	}

	base.Dons, err = rd.SelectDons(db, items["Dons"]...)
	if err != nil {
		return nil, err
	}

	base.Contraintes, err = rd.SelectContraintes(db, items["Contraintes"]...)
	if err != nil {
		return nil, err
	}

	base.Documents, err = rd.SelectDocuments(db, items["Documents"]...)
	if err != nil {
		return nil, err
	}

	base.Paiements, err = rd.SelectPaiements(db, items["Paiements"]...)
	if err != nil {
		return nil, err
	}

	base.Factures, err = rd.SelectFactures(db, items["Factures"]...)
	if err != nil {
		return nil, err
	}

	base.Messages, err = rd.SelectMessages(db, items["Messages"]...)
	if err != nil {
		return nil, err
	}

	rl, err := loadLinksById(db, items)
	if err != nil {
		return nil, err
	}
	base.ProcessRawLinks(rl)

	return base, nil
}

func (base BaseLocale) Hash() (BaseHash, error) {
	baseHash := make(BaseHash)
	var tmp map[int64]uint32

	tmp = make(map[int64]uint32, len(base.Personnes))
	for id, v := range base.Personnes {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["Personnes"] = tmp

	tmp = make(map[int64]uint32, len(base.Camps))
	for id, v := range base.Camps {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["Camps"] = tmp

	tmp = make(map[int64]uint32, len(base.Groupes))
	for id, v := range base.Groupes {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["Groupes"] = tmp

	tmp = make(map[int64]uint32, len(base.Sondages))
	for id, v := range base.Sondages {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["Sondages"] = tmp

	tmp = make(map[int64]uint32, len(base.Participants))
	for id, v := range base.Participants {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["Participants"] = tmp

	tmp = make(map[int64]uint32, len(base.Equipiers))
	for id, v := range base.Equipiers {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["Equipiers"] = tmp

	tmp = make(map[int64]uint32, len(base.Participantsimples))
	for id, v := range base.Participantsimples {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["Participantsimples"] = tmp

	tmp = make(map[int64]uint32, len(base.Structureaides))
	for id, v := range base.Structureaides {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["Structureaides"] = tmp

	tmp = make(map[int64]uint32, len(base.Aides))
	for id, v := range base.Aides {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["Aides"] = tmp

	tmp = make(map[int64]uint32, len(base.Organismes))
	for id, v := range base.Organismes {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["Organismes"] = tmp

	tmp = make(map[int64]uint32, len(base.Dons))
	for id, v := range base.Dons {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["Dons"] = tmp

	tmp = make(map[int64]uint32, len(base.Contraintes))
	for id, v := range base.Contraintes {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["Contraintes"] = tmp

	tmp = make(map[int64]uint32, len(base.Documents))
	for id, v := range base.Documents {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["Documents"] = tmp

	tmp = make(map[int64]uint32, len(base.Paiements))
	for id, v := range base.Paiements {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["Paiements"] = tmp

	tmp = make(map[int64]uint32, len(base.Factures))
	for id, v := range base.Factures {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["Factures"] = tmp

	tmp = make(map[int64]uint32, len(base.Messages))
	for id, v := range base.Messages {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["Messages"] = tmp

	tmp = make(map[int64]uint32, len(base.EquipierContraintes))
	for id, v := range base.EquipierContraintes {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["EquipierContraintes"] = tmp

	tmp = make(map[int64]uint32, len(base.ParticipantGroupe))
	for id, v := range base.ParticipantGroupe {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["ParticipantGroupe"] = tmp

	tmp = make(map[int64]uint32, len(base.ParticipantEquipier))
	for id, v := range base.ParticipantEquipier {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["ParticipantEquipier"] = tmp

	tmp = make(map[int64]uint32, len(base.GroupeContraintes))
	for id, v := range base.GroupeContraintes {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["GroupeContraintes"] = tmp

	tmp = make(map[int64]uint32, len(base.CampContraintes))
	for id, v := range base.CampContraintes {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["CampContraintes"] = tmp

	tmp = make(map[int64]uint32, len(base.DocumentPersonnes))
	for id, v := range base.DocumentPersonnes {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["DocumentPersonnes"] = tmp

	tmp = make(map[int64]uint32, len(base.DocumentAides))
	for id, v := range base.DocumentAides {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["DocumentAides"] = tmp

	tmp = make(map[int64]uint32, len(base.DocumentCamps))
	for id, v := range base.DocumentCamps {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["DocumentCamps"] = tmp

	tmp = make(map[int64]uint32, len(base.MessageDocuments))
	for id, v := range base.MessageDocuments {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["MessageDocuments"] = tmp

	tmp = make(map[int64]uint32, len(base.MessageSondages))
	for id, v := range base.MessageSondages {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["MessageSondages"] = tmp

	tmp = make(map[int64]uint32, len(base.MessagePlaceliberes))
	for id, v := range base.MessagePlaceliberes {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["MessagePlaceliberes"] = tmp

	tmp = make(map[int64]uint32, len(base.MessageAttestations))
	for id, v := range base.MessageAttestations {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["MessageAttestations"] = tmp

	tmp = make(map[int64]uint32, len(base.MessageMessages))
	for id, v := range base.MessageMessages {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["MessageMessages"] = tmp

	tmp = make(map[int64]uint32, len(base.DonDonateurs))
	for id, v := range base.DonDonateurs {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["DonDonateurs"] = tmp

	return baseHash, nil
}

func (base *BaseLocale) MergeFrom(incomming BaseLocale, toDelete map[string][]int64) {

	for id, v := range incomming.Personnes {
		base.Personnes[id] = v
	}
	for _, id := range toDelete["Personnes"] {
		delete(base.Personnes, id)
	}

	for id, v := range incomming.Camps {
		base.Camps[id] = v
	}
	for _, id := range toDelete["Camps"] {
		delete(base.Camps, id)
	}

	for id, v := range incomming.Groupes {
		base.Groupes[id] = v
	}
	for _, id := range toDelete["Groupes"] {
		delete(base.Groupes, id)
	}

	for id, v := range incomming.Sondages {
		base.Sondages[id] = v
	}
	for _, id := range toDelete["Sondages"] {
		delete(base.Sondages, id)
	}

	for id, v := range incomming.Participants {
		base.Participants[id] = v
	}
	for _, id := range toDelete["Participants"] {
		delete(base.Participants, id)
	}

	for id, v := range incomming.Equipiers {
		base.Equipiers[id] = v
	}
	for _, id := range toDelete["Equipiers"] {
		delete(base.Equipiers, id)
	}

	for id, v := range incomming.Participantsimples {
		base.Participantsimples[id] = v
	}
	for _, id := range toDelete["Participantsimples"] {
		delete(base.Participantsimples, id)
	}

	for id, v := range incomming.Structureaides {
		base.Structureaides[id] = v
	}
	for _, id := range toDelete["Structureaides"] {
		delete(base.Structureaides, id)
	}

	for id, v := range incomming.Aides {
		base.Aides[id] = v
	}
	for _, id := range toDelete["Aides"] {
		delete(base.Aides, id)
	}

	for id, v := range incomming.Organismes {
		base.Organismes[id] = v
	}
	for _, id := range toDelete["Organismes"] {
		delete(base.Organismes, id)
	}

	for id, v := range incomming.Dons {
		base.Dons[id] = v
	}
	for _, id := range toDelete["Dons"] {
		delete(base.Dons, id)
	}

	for id, v := range incomming.Contraintes {
		base.Contraintes[id] = v
	}
	for _, id := range toDelete["Contraintes"] {
		delete(base.Contraintes, id)
	}

	for id, v := range incomming.Documents {
		base.Documents[id] = v
	}
	for _, id := range toDelete["Documents"] {
		delete(base.Documents, id)
	}

	for id, v := range incomming.Paiements {
		base.Paiements[id] = v
	}
	for _, id := range toDelete["Paiements"] {
		delete(base.Paiements, id)
	}

	for id, v := range incomming.Factures {
		base.Factures[id] = v
	}
	for _, id := range toDelete["Factures"] {
		delete(base.Factures, id)
	}

	for id, v := range incomming.Messages {
		base.Messages[id] = v
	}
	for _, id := range toDelete["Messages"] {
		delete(base.Messages, id)
	}

	for id, v := range incomming.EquipierContraintes {
		base.EquipierContraintes[id] = v
	}
	for _, id := range toDelete["EquipierContraintes"] {
		delete(base.EquipierContraintes, id)
	}

	for id, v := range incomming.ParticipantGroupe {
		base.ParticipantGroupe[id] = v
	}
	for _, id := range toDelete["ParticipantGroupe"] {
		delete(base.ParticipantGroupe, id)
	}

	for id, v := range incomming.ParticipantEquipier {
		base.ParticipantEquipier[id] = v
	}
	for _, id := range toDelete["ParticipantEquipier"] {
		delete(base.ParticipantEquipier, id)
	}

	for id, v := range incomming.GroupeContraintes {
		base.GroupeContraintes[id] = v
	}
	for _, id := range toDelete["GroupeContraintes"] {
		delete(base.GroupeContraintes, id)
	}

	for id, v := range incomming.CampContraintes {
		base.CampContraintes[id] = v
	}
	for _, id := range toDelete["CampContraintes"] {
		delete(base.CampContraintes, id)
	}

	for id, v := range incomming.DocumentPersonnes {
		base.DocumentPersonnes[id] = v
	}
	for _, id := range toDelete["DocumentPersonnes"] {
		delete(base.DocumentPersonnes, id)
	}

	for id, v := range incomming.DocumentAides {
		base.DocumentAides[id] = v
	}
	for _, id := range toDelete["DocumentAides"] {
		delete(base.DocumentAides, id)
	}

	for id, v := range incomming.DocumentCamps {
		base.DocumentCamps[id] = v
	}
	for _, id := range toDelete["DocumentCamps"] {
		delete(base.DocumentCamps, id)
	}

	for id, v := range incomming.MessageDocuments {
		base.MessageDocuments[id] = v
	}
	for _, id := range toDelete["MessageDocuments"] {
		delete(base.MessageDocuments, id)
	}

	for id, v := range incomming.MessageSondages {
		base.MessageSondages[id] = v
	}
	for _, id := range toDelete["MessageSondages"] {
		delete(base.MessageSondages, id)
	}

	for id, v := range incomming.MessagePlaceliberes {
		base.MessagePlaceliberes[id] = v
	}
	for _, id := range toDelete["MessagePlaceliberes"] {
		delete(base.MessagePlaceliberes, id)
	}

	for id, v := range incomming.MessageAttestations {
		base.MessageAttestations[id] = v
	}
	for _, id := range toDelete["MessageAttestations"] {
		delete(base.MessageAttestations, id)
	}

	for id, v := range incomming.MessageMessages {
		base.MessageMessages[id] = v
	}
	for _, id := range toDelete["MessageMessages"] {
		delete(base.MessageMessages, id)
	}

	for id, v := range incomming.DonDonateurs {
		base.DonDonateurs[id] = v
	}
	for _, id := range toDelete["DonDonateurs"] {
		delete(base.DonDonateurs, id)
	}

}