Envoi de courriels

ICourrielClient regroupe cinq endpoints d'envoi de courriels : renvoi de la carte de membre numérique (par employé ou par emploi), envoi du lien d'un formulaire personnalisé (par employé ou par emploi), et envoi de courriels transactionnels libres.

Module requis : MaCarteDeMembre.

Client SDK : ICourrielClient.

1. Choisir la bonne méthode

Besoin	Méthode	Prérequis
Renvoyer la dernière carte de membre à un employé	`EnvoyerDerniereCarteMembre`	Une adhésion active sur l'employé
Renvoyer la carte pour un emploi spécifique (membre multi-employeurs)	`EnvoyerDerniereCarteMembrePourEmploi`	Un emploi actif côté MCM
Envoyer le lien d'un formulaire personnalisé à un employé	`EnvoyerFormulaire`	Le `IdFormulaire` (voir `IFormulaireClient.GetAllFormulaires`)
Envoyer un formulaire emploi-scopé	`EnvoyerFormulairePourEmploi`	Idem + un emploi
Envoyer un courriel libre (HTML ou texte)	`EnvoyerCourrielTransactionnel`	Aucun (le destinataire est libre)

Les quatre premières méthodes valident que le Courriel correspond au courriel principal ou alternatif de l'employé. Sinon, l'API retourne Courriel.NotAssociatedWithEmployee.

2. Renvoyer la carte de membre

var result = await courrielClient.EnvoyerDerniereCarteMembre(
    new B2BEnvoyerDerniereCarteMembreRequest
    {
        IdExterneEmploye = "PERSON001",
        Courriel = "alice@example.com"   // doit matcher principal ou alternatif
    });

if (result.IsError)
{
    logger.LogWarning("Carte non envoyée [{Code}]: {Desc}",
        result.FirstError.Code, result.FirstError.Description);
}

Variante par emploi — utile pour un membre qui a plusieurs emplois et reçoit une carte distincte par employeur :

await courrielClient.EnvoyerDerniereCarteMembrePourEmploi(
    new B2BEnvoyerDerniereCarteMembrePourEmploiRequest
    {
        IdExterneEmploi = "EMPLOI001",
        Courriel = "alice@example.com"
    });

3. Envoyer un formulaire

Étape 1 — récupérer la liste des formulaires disponibles :

var formulaires = await formulaireClient.GetAllFormulaires();
var adhesion = formulaires.Value.First(f => f.Nom == "Adhésion 2026");

Étape 2 — envoyer le lien personnalisé :

await courrielClient.EnvoyerFormulaire(new B2BEnvoyerFormulaire
{
    IdExterneEmploye = "PERSON001",
    Courriel = "alice@example.com",
    IdFormulaire = adhesion.Id
});

Le lien envoyé est pré-personnalisé (pré-rempli avec les données de l'employé) et le formulaire mémorise qui l'a soumis. Pas besoin de générer un token de votre côté.

Variante emploi-scopée — quand le formulaire dépend de l'emploi (par ex. déclaration spécifique à un employeur) :

await courrielClient.EnvoyerFormulairePourEmploi(
    new B2BEnvoyerFormulairePourEmploiRequest
    {
        IdExterneEmploi = "EMPLOI001",
        Courriel = "alice@example.com",
        IdFormulaire = adhesion.Id
    });

4. Courriels transactionnels libres

EnvoyerCourrielTransactionnel envoie un courriel arbitraire à n'importe quelle adresse via le fournisseur configuré côté MCM (Cakemail, SendGrid, Postmark, ou SMTP).

await courrielClient.EnvoyerCourrielTransactionnel(
    new B2BEnvoyerCourrielTransactionnelRequest
    {
        Destinataire = "support@partenaire.example.com",
        Sujet = "Votre rapport quotidien",
        Contenu = "<p>Voir le <a href=\"...\">tableau de bord</a>.</p>",
        EstHtml = true,                          // défaut
        ReplyTo = "noreply@partenaire.example.com",
        OmettrePiedDePage = false,               // ajoute le pied MCM par défaut
        Fournisseur = B2BMailerProviderType.SendGrid   // null = fournisseur actif
    });

Champs

Champ	Type	Note
`Destinataire`	`string`	Requis. Une seule adresse.
`Sujet`	`string`	Requis.
`Contenu`	`string`	Requis. HTML ou texte selon `EstHtml`.
`EstHtml`	`bool` (défaut `true`)	Mettez à `false` pour un message texte plat.
`ReplyTo`	`string?`	Surcharge le `reply-to` du fournisseur.
`OmettrePiedDePage`	`bool` (défaut `false`)	À `true` pour les courriels purement opérationnels (rappels, notifications API).
`Fournisseur`	`B2BMailerProviderType?`	`Cakemail`, `SendGrid`, `Postmark` ou `Smtp`. `null` utilise le fournisseur actif.

HTML : encodez les données utilisateur (WebUtility.HtmlEncode). MCM ne ré-échappe pas votre Contenu — vous êtes responsable des données dynamiques.

5. Bonnes pratiques

Idempotence : ces appels sont non idempotents — chaque appel envoie un courriel. Faites attention aux retries automatiques (Polly, queues). Préférez un DeliveryId métier de votre côté + table d'envoi pour ne pas spammer.
Adresse principale vs alternative : passez l'adresse exacte (chaîne, insensible à la casse). Si l'employé a changé d'adresse récemment, synchronisez avec IEmployesClient.UpdateCourriels avant l'envoi.
Limite de débit : aucune limite côté API à ce jour, mais respectez les limites de votre fournisseur (Cakemail = ~60 req/min sur le plan standard). Voir Limites de débit.
Pied de page : laissez OmettrePiedDePage = false (défaut) pour les courriels marketing — c'est requis pour la conformité CASL/CAN-SPAM.
Templates personnalisés : pour des templates riches, utilisez Cakemail côté MCM et appelez l'envoi de carte ou formulaire — ne reconstruisez pas les templates dans Contenu.

6. Erreurs courantes

Code	Cause	Action
`Courriel.NotAssociatedWithEmployee`	L'adresse passée n'est ni le principal ni l'alternatif de l'employé	Vérifier `B2BEmployeItem.Courriel` / `CourrielAlternatif`
`Employe.NotFound`	`IdExterneEmploye` inconnu	Synchroniser avant d'envoyer
`Emploi.NotFound`	`IdExterneEmploi` inconnu pour ce client	Vérifier `IEmploisClient.GetEmploiById`
`Formulaire.NotFound`	`IdFormulaire` inexistant ou désactivé	Re-lister via `GetAllFormulaires`
`Courriel.Invalid`	Adresse mal formée	Pré-valider de votre côté (regex / `MailAddress`)
`Courriel.ProvisionneurNonConfigure`	Aucun fournisseur d'envoi configuré côté MCM	Contactez l'admin MCM

7. Cas d'usage typiques

Renvoi groupé de cartes après mise à jour des courriels

// 1. Mettre à jour les courriels en lot
await employesClient.UpdateCourriels(updates);

// 2. Renvoyer la carte aux adresses corrigées
foreach (var u in updates)
{
    var nouveauCourriel = u.CourrielPrincipal ?? u.CourrielAlternatif;
    if (nouveauCourriel is null) continue;

    var send = await courrielClient.EnvoyerDerniereCarteMembre(
        new B2BEnvoyerDerniereCarteMembreRequest
        {
            IdExterneEmploye = u.IdExterne,
            Courriel = nouveauCourriel
        });

    if (send.IsError)
        logger.LogWarning("{Id} échec: {Err}", u.IdExterne, send.FirstError.Description);
}

Notification d'événement métier

// Quand votre système crée un grief
await courrielClient.EnvoyerCourrielTransactionnel(
    new B2BEnvoyerCourrielTransactionnelRequest
    {
        Destinataire = membre.Courriel,
        Sujet = $"Confirmation de votre grief #{griefId}",
        Contenu = $"<p>Bonjour {WebUtility.HtmlEncode(membre.Prenom)}, ...</p>",
        OmettrePiedDePage = true   // courriel opérationnel
    });

Voir aussi

ICourrielClient (référence)
IFormulaireClient (référence) — lister les formulaires disponibles
Endpoints HTTP — CourrielController
Guide — synchronisation des employés — UpdateCourriels pour corriger les adresses avant l'envoi
Limites de débit

1. Choisir la bonne méthode​

2. Renvoyer la carte de membre​

3. Envoyer un formulaire​

4. Courriels transactionnels libres​

Champs​

5. Bonnes pratiques​

6. Erreurs courantes​

7. Cas d'usage typiques​

Renvoi groupé de cartes après mise à jour des courriels​

Notification d'événement métier​

Voir aussi​