Aller au contenu principal

Démarrage rapide

Ce guide vous montre comment effectuer votre premier appel API avec MCM.ApiProxy.

Exemple complet​

Voici un exemple de service qui utilise le client employés :

Services/EmployeService.cs
using MCM.ApiProxy.Contracts;
using MCM.B2B.Contracts;

public class EmployeService
{
    private readonly IEmployesClient _employesClient;
    private readonly ILogger<EmployeService> _logger;

    public EmployeService(
        IEmployesClient employesClient,
        ILogger<EmployeService> logger)
    {
        _employesClient = employesClient;
        _logger = logger;
    }

    public async Task<List<B2BEmployeItem>> GetAllEmployesAsync()
    {
        var result = await _employesClient.GetAllEmployes();

        if (result.IsError)
        {
            _logger.LogError("Erreur lors de la récupération des employés: {Error}",
                result.FirstError.Description);
            return [];
        }

        return result.Value.ToList();
    }

    public async Task<B2BEmployeItem?> GetEmployeAsync(string idExterne)
    {
        var result = await _employesClient.GetEmployeById(idExterne);

        if (result.IsError)
        {
            _logger.LogWarning("Employé non trouvé: {IdExterne}", idExterne);
            return null;
        }

        return result.Value;
    }
}

Enregistrer le service​

Program.cs
using MCM.ApiProxy;

var builder = WebApplication.CreateBuilder(args);

// MCM API
builder.Services.AddMcmApiClient(builder.Configuration);

// Votre service
builder.Services.AddScoped<EmployeService>();

var app = builder.Build();

Utiliser dans un contrôleur​

Controllers/EmployesController.cs
[ApiController]
[Route("api/[controller]")]
public class EmployesController : ControllerBase
{
    private readonly EmployeService _employeService;

    public EmployesController(EmployeService employeService)
    {
        _employeService = employeService;
    }

    [HttpGet]
    public async Task<IActionResult> GetAll()
    {
        var employes = await _employeService.GetAllEmployesAsync();
        return Ok(employes);
    }

    [HttpGet("{idExterne}")]
    public async Task<IActionResult> GetById(string idExterne)
    {
        var employe = await _employeService.GetEmployeAsync(idExterne);

        if (employe is null)
            return NotFound();

        return Ok(employe);
    }
}

Comprendre le pattern ErrorOr​

MCM.ApiProxy utilise le pattern ErrorOr<T> pour gérer les erreurs de manière explicite :

var result = await _employesClient.GetEmployeById("EMP-123");

// Vérifier s'il y a une erreur
if (result.IsError)
{
    // Accéder à la première erreur
    var error = result.FirstError;
    Console.WriteLine($"Code: {error.Code}");
    Console.WriteLine($"Description: {error.Description}");
    return;
}

// Accéder à la valeur
var employe = result.Value;
Console.WriteLine($"Employé: {employe.Prenom} {employe.Nom}");

Avantages de ErrorOr​

AspectErrorOrExceptions
Performance✅ Pas d'overhead❌ Coûteux à lancer
Lisibilité✅ Flux explicite❌ Flux caché
Compilation✅ Vérifié à la compilation❌ Erreurs runtime

Créer un employé​

public async Task<bool> CreateEmployeAsync(B2BUpdateEmployeDto employe)
{
    var result = await _employesClient.AddEmploye(employe);

    if (result.IsError)
    {
        _logger.LogError("Erreur création employé: {Error}",
            result.FirstError.Description);
        return false;
    }

    _logger.LogInformation("Employé créé: {IdExterne}", employe.IdExterne);
    return true;
}

Prochaines étapes​