Lab

// Couche Repository
public interface ICommandeRepository
{
    Task<IEnumerable<Commande>> GetAllAsync();
    Task<Commande> GetByIdAsync(int id);
    Task AddAsync(Commande commande);
}

// Couche Service
public class CommandeService
{
    private readonly ICommandeRepository _repo;
    public CommandeService(ICommandeRepository repo)
        => _repo = repo;

    public async Task<Commande> GetAsync(int id)
        => await _repo.GetByIdAsync(id)
           ?? throw new NotFoundException($"Commande {id} introuvable");
}

// Couche Controller
[ApiController, Route("api/[controller]")]
public class CommandesController : ControllerBase
{
    private readonly CommandeService _svc;
    public CommandesController(CommandeService svc) => _svc = svc;

    [HttpGet("{id}")]
    public async Task<IActionResult> Get(int id)
        => Ok(await _svc.GetAsync(id));
}

{ AVANT — Delphi }
function CalculerSalaire(brut: Double; taux: Double): Double;
begin
  if taux <= 0 then
    ShowMessage('Taux invalide')
  else
    Result := brut * (1 - taux / 100);
end;

// APRÈS — C# moderne
public static decimal CalculerSalaireNet(
    decimal brut, decimal tauxCotisation)
{
    if (tauxCotisation <= 0 || tauxCotisation >= 100)
        throw new ArgumentOutOfRangeException(
            nameof(tauxCotisation),
            "Le taux doit être entre 0 et 100");

    return brut * (1 - tauxCotisation / 100);
}

// Startup.cs — Configuration JWT
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(opt => {
        opt.TokenValidationParameters = new TokenValidationParameters {
            ValidateIssuer           = true,
            ValidateAudience         = true,
            ValidateLifetime         = true,
            ValidateIssuerSigningKey = true,
            ValidIssuer    = config["Jwt:Issuer"],
            ValidAudience  = config["Jwt:Audience"],
            IssuerSigningKey = new SymmetricSecurityKey(
                Encoding.UTF8.GetBytes(config["Jwt:Key"]))
        };
    });

// Controller sécurisé
[Authorize(Roles = "Admin,Medecin")]
[ApiController, Route("api/[controller]")]
public class DossierMedicalController : ControllerBase
{
    [HttpGet("{patientId}")]
    public async Task<IActionResult> GetDossier(int patientId)
    {
        var userId = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
        return Ok(await _service.GetDossierAsync(patientId, userId));
    }
}

-- Index couvrant sur la table Transport
CREATE INDEX IX_Transport_Date_Statut
    ON Transport (DateDepart, Statut)
    INCLUDE (PatientId, ChauffeurId, Montant);

-- Requête avec CTE + pagination
WITH TransportCTE AS (
    SELECT
        t.Id, t.DateDepart, t.Montant,
        p.Nom + ' ' + p.Prenom AS Patient,
        ROW_NUMBER() OVER (
            ORDER BY t.DateDepart DESC) AS RowNum
    FROM Transport t
    INNER JOIN Patient p ON p.Id = t.PatientId
    WHERE t.DateDepart >= DATEADD(month, -3, GETDATE())
      AND t.Statut = 'TERMINE'
)
SELECT * FROM TransportCTE
WHERE RowNum BETWEEN @PageStart AND @PageEnd;

// Angular — Intercepteur HTTP JWT
@Injectable()
export class AuthInterceptor implements HttpInterceptor {
  intercept(req: HttpRequest<any>, next: HttpHandler) {
    const token = localStorage.getItem('token');
    const authReq = token ? req.clone({
      setHeaders: { Authorization: `Bearer ${token}` }
    }) : req;
    return next.handle(authReq).pipe(
      catchError(err => err.status === 401
        ? this.auth.logout() : throwError(err))
    );
  }
}

// Nest.js — Controller sécurisé
@Controller('projets')
@UseGuards(JwtAuthGuard)
export class ProjetsController {
  @Get()
  findAll(@Request() req) {
    return this.projetsService.findAll(req.user.id);
  }
}

// Service IA pour résumé de dossier
public class IADossierService
{
    private readonly OpenAIClient _client;

    public async Task<string> ResumerDossierAsync(
        DossierMedical dossier)
    {
        var prompt = $"""
            Résume ce dossier médical en 3 lignes :
            Patient : {dossier.Patient}
            Antécédents : {dossier.Antecedents}
            Dernière visite : {dossier.DerniereVisite}
            """;

        var response = await _client
            .GetChatClient("gpt-4o-mini")
            .CompleteChatAsync(prompt);

        return response.Value.Content[0].Text;
    }
}