Aller au contenu principal

ISyncClient

Client pour la synchronisation en lot des données entre votre système et MCM. Permet de synchroniser syndicats (avec employeurs imbriqués), employés (avec emplois et adhésions) et objets de consentement en une seule opération.

public interface ISyncClient : IBaseClient

Méthodes​

Sync​

Synchronise les données en lot (V2).

Task<ErrorOr<B2BSyncEmployesResultV2>> Sync(
    ICollection<B2BUpdateSyndicatDtoV2> syndicatDtos,
    ICollection<B2BUpsertEmployeDtoV2> employeDtos,
    ICollection<B2BUpdateObjetConsentementDto> objetConsentementDtos)

Paramètres:

NomTypeDescription
syndicatDtosICollection<B2BUpdateSyndicatDtoV2>Syndicats à synchroniser (avec employeurs imbriqués)
employeDtosICollection<B2BUpsertEmployeDtoV2>Employés à synchroniser (avec emplois et adhésions)
objetConsentementDtosICollection<B2BUpdateObjetConsentementDto>Objets de consentement à synchroniser

Retour: B2BSyncEmployesResultV2 contenant le résultat détaillé par entité (syndicats, employeurs, employés, emplois, adhésions, objets de consentement).

Comportement Upsert

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

V2 - Structure hiérarchique

En V2, les employeurs sont imbriqués dans les syndicats (B2BUpdateSyndicatDtoV2.Employeurs) et les emplois/adhésions sont imbriqués dans les employés (B2BUpsertEmployeDtoV2.Emplois, B2BUpsertEmployeDtoV2.Adhesions). Cette structure reflète les relations du domaine.

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 syndicats avec leurs employeurs imbriqués
        var syndicats = new List<B2BUpdateSyndicatDtoV2>
        {
            new()
            {
                IdentifiantExterne = "SYND-001",
                Nom = "Syndicat des travailleurs",
                Employeurs =
                [
                    new()
                    {
                        IdExterne = "EMPL-001",
                        Nom = "Entreprise ABC Inc."
                    },
                    new()
                    {
                        IdExterne = "EMPL-002",
                        Nom = "Entreprise XYZ Ltée"
                    }
                ]
            }
        };

        // Préparer les employés avec emplois et adhésions imbriqués
        var employes = new List<B2BUpsertEmployeDtoV2>
        {
            new()
            {
                IdExterne = "EMP-001",
                Prenom = "Jean",
                Nom = "Dupont",
                NoMembre = "M-001",
                Courriel = "jean.dupont@example.com",
                Emplois =
                [
                    new()
                    {
                        IdentifiantExterne = "EMPLOI-001",
                        IdentifiantExterneEmployeur = "EMPL-001",
                        Matricule = "MAT-001",
                        DateDebut = new DateTime(2024, 1, 1)
                    }
                ],
                Adhesions =
                [
                    new()
                    {
                        IdentifiantExterneSyndicat = "SYND-001",
                        DateSignature = new DateTime(2024, 1, 15)
                    }
                ]
            }
        };

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

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

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

        // Analyser le résultat détaillé par entité
        var syncResult = result.Value;
        _logger.LogInformation(
            "Syndicats - Ajoutés: {Added}, Modifiés: {Updated}, Erreurs: {Errors}",
            syncResult.Syndicats.AddCount,
            syncResult.Syndicats.UpdateCount,
            syncResult.Syndicats.Erreurs.Count);

        _logger.LogInformation(
            "Employeurs - Ajoutés: {Added}, Modifiés: {Updated}, Erreurs: {Errors}",
            syncResult.Employeurs.AddCount,
            syncResult.Employeurs.UpdateCount,
            syncResult.Employeurs.Erreurs.Count);

        _logger.LogInformation(
            "Employés - Ajoutés: {Added}, Modifiés: {Updated}, Erreurs: {Errors}",
            syncResult.Employes.AddCount,
            syncResult.Employes.UpdateCount,
            syncResult.Employes.Erreurs.Count);

        _logger.LogInformation(
            "Emplois - Ajoutés: {Added}, Modifiés: {Updated}, Erreurs: {Errors}",
            syncResult.Emplois.AddCount,
            syncResult.Emplois.UpdateCount,
            syncResult.Emplois.Erreurs.Count);

        _logger.LogInformation(
            "Adhésions - Ajoutés: {Added}, Modifiés: {Updated}, Erreurs: {Errors}",
            syncResult.Adhesions.AddCount,
            syncResult.Adhesions.UpdateCount,
            syncResult.Adhesions.Erreurs.Count);

        return true;
    }
}

Bonnes pratiques​

Synchronisation par lots​

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

public async Task SyncEnLotsAsync(IEnumerable<B2BUpsertEmployeDtoV2> 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(
            Array.Empty<B2BUpdateSyndicatDtoV2>(),
            lot,
            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(
        Array.Empty<B2BUpdateSyndicatDtoV2>(),
        employesModifies.ToList(),
        Array.Empty<B2BUpdateObjetConsentementDto>());
}

Types associés​