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

package acvegestion

import (
	"errors"

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

// unifie la procédure de rapprochement d'une personne temporaire
// avec une personne existante
type identifieOut interface {
	//  modifie sur place le destinataire
	// la table de 'idTarget' dépend du context
	// dans le cas d'un nouveau profil on charge simplement l'item, attendu par le client
	updateTarget(tx rd.DB, paramsIn apiserver.IdentifiePersonneIn, idTarget int64) (err error)
}

type identEquipierOut apiserver.IdentifieEquipierOut

func (t *identEquipierOut) updateTarget(tx rd.DB, paramsIn apiserver.IdentifiePersonneIn, idTarget int64) (err error) {
	if paramsIn.Rattache {
		row := tx.QueryRow("UPDATE equipiers SET id_personne = $1 WHERE id = $2 RETURNING *", paramsIn.IdPersonneTarget, idTarget)
		t.Equipier, err = rd.ScanEquipier(row)
	} else {
		t.Equipier, err = rd.SelectEquipier(tx, idTarget)
	}
	return err
}

type identParticipantOut apiserver.IdentifieParticipantOut

func (t *identParticipantOut) updateTarget(tx rd.DB, paramsIn apiserver.IdentifiePersonneIn, idTarget int64) (err error) {
	if paramsIn.Rattache {
		row := tx.QueryRow("UPDATE participants SET id_personne = $1 WHERE id = $2 RETURNING *", paramsIn.IdPersonneTarget, idTarget)
		t.Participant, err = rd.ScanParticipant(row)
	} else {
		t.Participant, err = rd.SelectParticipant(tx, idTarget)
	}
	return err
}

type identResponsableOut apiserver.IdentifieResponsableOut

func (t *identResponsableOut) updateTarget(tx rd.DB, paramsIn apiserver.IdentifiePersonneIn, idTarget int64) (err error) {
	if paramsIn.Rattache {
		row := tx.QueryRow("UPDATE factures SET id_personne = $1 WHERE id = $2 RETURNING *", paramsIn.IdPersonneTarget, idTarget)
		t.Facture, err = rd.ScanFacture(row)
	} else {
		t.Facture, err = rd.SelectFacture(tx, idTarget)
	}
	return err
}

type identParticipantsimpleOut apiserver.IdentifieParticipantsimpleOut

func (t *identParticipantsimpleOut) updateTarget(tx rd.DB, paramsIn apiserver.IdentifiePersonneIn, idTarget int64) (err error) {
	if paramsIn.Rattache {
		row := tx.QueryRow("UPDATE participantsimples SET id_personne = $1 WHERE id = $2 RETURNING *", paramsIn.IdPersonneTarget, idTarget)
		t.Participantsimple, err = rd.ScanParticipantsimple(row)
	} else {
		t.Participantsimple, err = rd.SelectParticipantsimple(tx, idTarget)
	}

	return err
}

// 1 - modifie sur place `outTarget`; 2 -renvoie les changements relatif à la personne
func (ct Controller) identifiePersonne(in apiserver.IdentifiePersonneIn, idTarget int64, outTarget identifieOut) (out apiserver.IdentifiePersonneOut, err error) {
	if in.Rattache && in.IdPersonneTmp == in.IdPersonneTarget {
		return out, errors.New("Impossible de rattacher une personne à elle-même.")
	}

	tx, err := ct.DB.Begin()
	if err != nil {
		return out, err
	}

	if !in.Rattache {
		// on marque simplement la personne actuelle comme non temporaire
		row := tx.QueryRow("UPDATE personnes SET is_temporaire = FALSE WHERE id = $1 RETURNING *", in.IdPersonneTmp)
		out.Personne, err = rd.ScanPersonne(row)
		if err != nil {
			return out, shared.Rollback(tx, err)
		}
		out.DeletedPersonne = -1
		err = outTarget.updateTarget(ct.DB, in, idTarget) // aucune modification
		if err != nil {
			return out, shared.Rollback(tx, err)
		}
		err = tx.Commit()
		return out, err
	}

	// on commence par appliquer les modifications (imposées par le client)
	// en se restreignant aux champs concernés
	out.Personne, err = rd.SelectPersonne(tx, in.IdPersonneTarget)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	out.Personne.BasePersonne = in.Modifications // on applique les changements
	out.Personne, err = out.Personne.Update(tx)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}

	// on supprime les doublons dictés par le client
	// liens
	_, err = rd.DeleteDocumentPersonnesByIdDocuments(tx, in.SupprimeDocuments...)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	// contenu
	_, err = rd.DeleteContenuDocumentsByIdDocuments(tx, in.SupprimeDocuments...)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	// documents
	out.DeletedDocs, err = rd.DeleteDocumentsByIds(tx, in.SupprimeDocuments...)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}

	// on redirige les documents de la personne temporaire vers la nouvelle personne
	rows, err := tx.Query("UPDATE document_personnes SET id_personne = $1 WHERE id_personne = $2 RETURNING *", in.IdPersonneTarget, in.IdPersonneTmp)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	out.Documents, err = rd.ScanDocumentPersonnes(rows)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}

	// on redirige l'item (equipier, facture, participant, participantsimple) vers la nouvelle personne
	err = outTarget.updateTarget(tx, in, idTarget)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}

	// concernant la personne "temporaire" il y a deux cas :
	//	- soit elle est vraiment temporaire (cas usuel)
	//	- soit elle est déjà authentifié, et le client demande quand même
	//	  une redirection
	old, err := rd.SelectPersonne(tx, in.IdPersonneTmp)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	if old.IsTemporaire {
		// on la supprime
		_, err = rd.DeletePersonneById(tx, in.IdPersonneTmp)
		if err != nil {
			return out, shared.Rollback(tx, err)
		}
		out.DeletedPersonne = in.IdPersonneTmp
	} else {
		// sinon on la laisse
		out.DeletedPersonne = -1
	}
	err = tx.Commit()
	return out, err
}

func (ct Controller) identifieEquipier(in apiserver.IdentifieEquipierIn) (apiserver.IdentifieEquipierOut, error) {
	var out apiserver.IdentifieEquipierOut
	outPer, err := ct.identifiePersonne(in.IdentifiePersonneIn, in.IdEquipier, (*identEquipierOut)(&out))
	out.IdentifiePersonneOut = outPer
	return out, err
}

func (ct Controller) identifieParticipant(in apiserver.IdentifieParticipantIn) (apiserver.IdentifieParticipantOut, error) {
	var out apiserver.IdentifieParticipantOut
	outPer, err := ct.identifiePersonne(in.IdentifiePersonneIn, in.IdParticipant, (*identParticipantOut)(&out))
	out.IdentifiePersonneOut = outPer
	return out, err
}

func (ct Controller) identifieResponsable(in apiserver.IdentifieResponsableIn) (apiserver.IdentifieResponsableOut, error) {
	var out apiserver.IdentifieResponsableOut
	outPer, err := ct.identifiePersonne(in.IdentifiePersonneIn, in.IdFacture, (*identResponsableOut)(&out))
	out.IdentifiePersonneOut = outPer
	return out, err
}

func (ct Controller) identifieParticipantsimple(in apiserver.IdentifieParticipantsimpleIn) (apiserver.IdentifieParticipantsimpleOut, error) {
	var out apiserver.IdentifieParticipantsimpleOut
	outPer, err := ct.identifiePersonne(in.IdentifiePersonneIn, in.IdParticipantsimple, (*identParticipantsimpleOut)(&out))
	out.IdentifiePersonneOut = outPer
	return out, err
}