Aller au contenu principal

ISyncClient

Client pour la synchronisation en lot des données entre votre système et MCM. Permet de synchroniser employés, employeurs et objets de consentement en une seule opération.

public interface ISyncClient : IBaseClient

Méthodes​

Sync​

Synchronise les données en lot.

Task<ErrorOr<B2BSyncEmployesResult>> Sync(
    ICollection<B2BUpsertEmployeDto> employeDtos,
    ICollection<B2BUpdateEmployeurDto> employeursDtos,
    ICollection<B2BUpdateObjetConsentementDto> objetConsentementDtos)

Paramètres:

NomTypeDescription
employeDtosICollection<B2BUpsertEmployeDto>Employés à synchroniser
employeursDtosICollection<B2BUpdateEmployeurDto>Employeurs à synchroniser
objetConsentementDtosICollection<B2BUpdateObjetConsentementDto>Objets de consentement à synchroniser

Retour: B2BSyncEmployesResult contenant le résultat de la synchronisation avec les erreurs éventuelles.

Comportement Upsert

La synchronisation utilise un comportement "upsert" : les enregistrements existants sont mis à jour et les nouveaux sont créés.

Exemple complet:

public class SyncService
{
    private readonly ISyncClient _syncClient;
    private readonly ILogger<SyncService> _logger;

    public SyncService(ISyncClient syncClient, ILogger<SyncService> logger)
    {
        _syncClient = syncClient;
        _logger = logger;
    }

    public async Task<bool> SynchroniserDonneesAsync()
    {
        // Préparer les données
        var employes = new List<B2BUpsertEmployeDto>
        {
            new()
            {
                IdExterne = "EMP-001",
                Prenom = "Jean",
                Nom = "Dupont",
                NoMembre = "M-001",
                Courriel = "jean.dupont@example.com",
                IdentifiantExterneEmployeur = "EMPL-001"
            },
            new()
            {
                IdExterne = "EMP-002",
                Prenom = "Marie",
                Nom = "Tremblay",
                NoMembre = "M-002",
                Courriel = "marie.tremblay@example.com",
                IdentifiantExterneEmployeur = "EMPL-001"
            }
        };

        var employeurs = new List<B2BUpdateEmployeurDto>
        {
            new()
            {
                IdExterne = "EMPL-001",
                Nom = "Entreprise ABC Inc."
            }
        };

        var objetsConsentement = new List<B2BUpdateObjetConsentementDto>
        {
            new()
            {
                IdExterne = "CONSENT-001",
                Nom = "Communications marketing"
            }
        };

        // Exécuter la synchronisation
        var result = await _syncClient.Sync(employes, employeurs, objetsConsentement);

        if (result.IsError)
        {
            _logger.LogError("Erreur de synchronisation: {Error}",
                result.FirstError.Description);
            return false;
        }

        // Analyser le résultat
        var syncResult = result.Value;
        _logger.LogInformation(
            "Sync terminée - Créés: {Created}, Modifiés: {Updated}, Erreurs: {Errors}",
            syncResult.Created,
            syncResult.Updated,
            syncResult.Errors?.Count ?? 0);

        // Traiter les erreurs individuelles
        if (syncResult.Errors?.Any() == true)
        {
            foreach (var error in syncResult.Errors)
            {
                _logger.LogWarning("Erreur sync {Id}: {Message}",
                    error.IdExterne, error.Message);
            }
        }

        return true;
    }
}

Bonnes pratiques​

Synchronisation par lots​

Pour de grandes quantités de données, divisez en lots :

public async Task SyncEnLotsAsync(IEnumerable<B2BUpsertEmployeDto> tousLesEmployes)
{
    const int tailleLot = 100;
    var lots = tousLesEmployes
        .Select((e, i) => new { Employe = e, Index = i })
        .GroupBy(x => x.Index / tailleLot)
        .Select(g => g.Select(x => x.Employe).ToList());

    foreach (var lot in lots)
    {
        var result = await _syncClient.Sync(
            lot,
            Array.Empty<B2BUpdateEmployeurDto>(),
            Array.Empty<B2BUpdateObjetConsentementDto>());

        if (result.IsError)
        {
            _logger.LogError("Erreur lot: {Error}", result.FirstError.Description);
            // Décider si on continue ou arrête
        }

        // Optionnel: délai entre les lots
        await Task.Delay(100);
    }
}

Synchronisation incrémentale​

Utilisez les dates de modification pour sync incrémentale :

public async Task SyncIncrementaleAsync(DateTime dernierSync)
{
    // Récupérer seulement les employés modifiés depuis dernierSync
    var employesModifies = await _votreRepository
        .GetEmployesModifiesDepuis(dernierSync);

    await _syncClient.Sync(
        employesModifies.ToList(),
        Array.Empty<B2BUpdateEmployeurDto>(),
        Array.Empty<B2BUpdateObjetConsentementDto>());
}

Types associés​