Premier message en 5 minutes

Envoyer un message chiffré à un destinataire, et laisser Secure Exchanges lui envoyer le courriel.

Prérequis

Le paquet de votre langage installé : Choisir son paquet.
Vos trois identifiants de préproduction : Identifiants et environnements.

Le code complet

using System;
using System.Collections.Generic;
using SecureExchangesSDK.Helpers;
using SecureExchangesSDK.Models.Args;
using SecureExchangesSDK.Models.Entity;
using SecureExchangesSDK.SecureExchanges;

internal static class PremierMessage
{
    private static void Main()
    {
        // Vos identifiants viennent de votre coffre de secrets, jamais du code.
        Guid serial = LireSecret("SecureExchanges:Serial");
        Guid apiUser = LireSecret("SecureExchanges:ApiUser");
        Guid apiPassword = LireSecret("SecureExchanges:ApiPassword");

        // Production. Pour la préproduction, voir « Identifiants et environnements ».
        var endpoint = new Uri("https://www.secure-exchanges.com/_api/0217/0217.asmx");

        var recipients = new List<RecipientInfo>
        {
            new RecipientInfo { Email = "destinataire@example.com" }
        };

        var args = new MutliRecipientArgs(
            endPointUri: endpoint, serial: serial, user: apiUser, psw: apiPassword,
            recipients: recipients,
            message: "Bonjour, voici un message sécurisé.",
            subject: "Message confidentiel",
            password: null, filesList: null,
            sendMode: SendMethodEnum.onlyEmail,
            getBackHtml: false,          // Secure Exchanges envoie le courriel
            showSubject: true,           // obsolète, sans effet, mais exigé par le constructeur
            getNotify: true,
            cultureID: "fr-CA",
            maximumOpenTime: 5,          // nombre d'ouvertures permises
            minutesExpiration: 1440);    // 24 heures

        var response = MessageHelper.MultiRecipientMessage(args);

        // Le lien remis au destinataire donne accès au message : ne le journalisez pas.
        if (response.Status == 200)
            Console.WriteLine($"Envoyé à {response.RecipientsAnswer.Count} destinataire(s).");
        else
            Console.WriteLine($"Échec, statut {response.Status}");   // voir Codes de statut
    }

    private static Guid LireSecret(string nom)
    {
        // À remplacer : lecture dans votre gestionnaire de secrets (Azure Key Vault, etc.).
        throw new NotImplementedException(nom);
    }
}

"""Premier message : envoi chiffré à un destinataire, courriel envoyé par Secure Exchanges."""

import uuid

from secure_exchanges_sdk.client import SecureExchangesClient, SEMSClient
from secure_exchanges_sdk.helpers.message_helper import MessageHelper
from secure_exchanges_sdk.helpers.settings_helper import SettingsHelper
from secure_exchanges_sdk.models.entity.recipient_info import RecipientInfo


def lire_secret(nom: str) -> uuid.UUID:
    """À remplacer : lecture dans votre gestionnaire de secrets (Azure Key Vault, etc.)."""
    raise NotImplementedError(nom)


def main() -> None:
    cfg = SettingsHelper.configure_preview()  # configure_production() en production
    client = SecureExchangesClient(cfg["api_endpoint"])
    sems_client = SEMSClient(cfg["sems_endpoint"])

    answer = MessageHelper.multi_recipient_message(
        api_client=client,
        sems_client=sems_client,
        serial=lire_secret("SecureExchanges:Serial"),
        api_user=lire_secret("SecureExchanges:ApiUser"),
        api_password=lire_secret("SecureExchanges:ApiPassword"),
        recipients=[RecipientInfo(email="destinataire@example.com")],
        message="<p>Bonjour, voici un message sécurisé.</p>",
        subject="Message confidentiel",
        culture_id="fr-CA",
        get_back_html=False,  # Secure Exchanges envoie le courriel
        maximum_open_time=5,  # 1 par défaut
    )

    # Le lien remis au destinataire donne accès au message : ne le journalisez pas.
    if answer.status == 200:
        print(f"Envoyé à {len(answer.recipients_answer)} destinataire(s).")
    else:
        print(f"Échec, statut {answer.status}")  # voir Codes de statut


if __name__ == "__main__":
    main()

<?php

declare(strict_types=1);

require __DIR__ . '/vendor/autoload.php';

use SecureExchanges\SDK\Client\SecureExchangesClient;
use SecureExchanges\SDK\Client\SEMSClient;
use SecureExchanges\SDK\Helpers\MessageHelper;
use SecureExchanges\SDK\Helpers\SettingsHelper;
use SecureExchanges\SDK\Models\Entity\RecipientInfo;

/** À remplacer : lecture dans votre gestionnaire de secrets (Azure Key Vault, etc.). */
function lireSecret(string $nom): string
{
    throw new RuntimeException($nom);
}

$endpoints = SettingsHelper::configurePreview();   // configureProduction() en production
$client = new SecureExchangesClient($endpoints['apiEndpoint']);
$sems = new SEMSClient($endpoints['semsEndpoint']);

$answer = MessageHelper::multiRecipientMessage(
    apiClient: $client,
    serial: lireSecret('SecureExchanges:Serial'),
    apiUser: lireSecret('SecureExchanges:ApiUser'),
    apiPassword: lireSecret('SecureExchanges:ApiPassword'),
    recipients: [new RecipientInfo(email: 'destinataire@example.com')],
    message: 'Bonjour, voici un message sécurisé.',
    subject: 'Message confidentiel',
    getBackHtml: false,      // Secure Exchanges envoie le courriel
    cultureId: 'fr-CA',
    maximumOpenTime: 5,      // 1 par défaut
    semsClient: $sems,
);

// Le lien remis au destinataire donne accès au message : ne le journalisez pas.
if ($answer->status === 200) {
    echo 'Envoyé à ' . count($answer->recipientsAnswer ?? []) . " destinataire(s).\n";
} else {
    echo 'Échec, statut ' . $answer->status . "\n";   // voir Codes de statut
}

Important

Qui envoie le courriel au destinataire ? Avec getBackHtml à false, Secure Exchanges l'envoie. À true, le SDK vous renvoie le courriel en HTML et c'est votre application qui doit l'envoyer.

Attention

true est la valeur par défaut. Si votre destinataire ne reçoit rien, vérifiez d'abord cette option.

Vérifier que ça fonctionne

Le statut retourné par MultiRecipientMessage doit être 200. Le destinataire reçoit un courriel contenant son lien et consulte le message dans la page sécurisée de Secure Exchanges.