Donne aux numéros de revue leur couverture et leur une, et un tiret à l'ISSN

L'ISSN est désormais rangé sous sa forme à tiret, et pas seulement affiché ainsi.
C'est le seul endroit où le projet s'écarte de « la valeur stockée reste nue »,
et il y a une raison : le code-barres produit déjà un ISSN à tiret, et la BnF
interroge `bib.issn` avec le tiret. Un ISSN tapé « 24666718 » ne se rapprochait
donc de rien, et le scan suivant créait une seconde fiche à côté. La canonisation
a lieu avant la recherche, pas seulement à l'écriture. Les champs de saisie, eux,
gardent la valeur tapée : découper à la frappe se battrait avec le curseur.

`ServiceRenormalisation` rattrape les ISSN existants — par un passage dédié, le
mécanisme générique confondant tous les NULL en une seule clé, alors que
l'unicité est ici un index partiel. Une fiche dont la forme canonique est déjà
prise garde la sienne : le serveur doit démarrer.

La couverture d'un numéro est une URL collée, jamais une photo : aucune source ne
peut la fournir, l'ISSN désignant la revue et non la parution, et le projet ne
stocke aucun fichier. Le garde du relais de couvertures a donc été étendu aux
numéros — l'oublier n'aurait produit aucune erreur visible, seulement une image
présente en ligne et absente hors-ligne.

Les articles à la une vivent dans une table à part et non dans `Theme` : un thème
est un vocabulaire qu'on réutilise, un titre d'article est unique à sa parution.
Rien ne se partage, donc pas de n-n — une simple clé étrangère vers le numéro.
Ils se saisissent au point-virgule seul : « Ukraine, deux ans après » serait
coupé en deux par la virgule.

Un PUT sur le numéro était indispensable : on note un numéro le jour où on le
range et on en recopie le sommaire plus tard. Sans lui, couverture et une
n'auraient existé qu'à la création, c'est-à-dire jamais.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

MaBibli.Tests/ServiceRevuesTests.cs

@@ -171,6 +171,142 @@ public class ServiceRevuesTests : IDisposable
         Assert.NotNull(issnPris.Erreur);
     }
 
+    /// <summary>
+    /// ⚠️ Le cas qui a motivé la canonisation (lot K2) : une revue saisie à la main, ISSN tapé
+    /// sans tiret, doit être <b>retrouvée</b> par le scan — qui produit toujours la forme à
+    /// tiret. Sans elle, le code-barres créait une seconde fiche à côté de la première.
+    /// </summary>
+    [Fact]
+    public async Task Un_issn_sans_tiret_designe_la_meme_revue_que_le_code_barres()
+    {
+        var aLaMain = await RevueAsync("Médor", issn: "24666718");
+
+        Assert.Equal("2466-6718", aLaMain.Issn);
+
+        var scanne = await RevueAsync("Médor (Bruxelles)", issn: "2466-6718");
+
+        Assert.Equal(aLaMain.Id, scanne.Id);
+        Assert.Single(await _revues.ListerAsync());
+    }
+
+    [Fact]
+    public async Task Un_numero_porte_sa_couverture_et_ses_articles_a_la_une()
+    {
+        var revue = await RevueAsync();
+
+        var apres = await _revues.AjouterNumeroAsync(revue.Id, new AjoutNumeroRevue
+        {
+            Numero = "43",
+            CoverUrl = "https://exemple.fr/medor-43.jpg",
+            Articles = ["Ukraine, deux ans après", "Le retour du train de nuit"],
+        });
+
+        var numero = Assert.Single(apres.Revue!.Numeros);
+
+        Assert.Equal("https://exemple.fr/medor-43.jpg", numero.CoverUrl);
+        Assert.Equal(["Ukraine, deux ans après", "Le retour du train de nuit"], numero.Articles);
+    }
+
+    /// <summary>
+    /// La une se recopie <b>après coup</b> : on note un numéro le jour où on le range, on en
+    /// recopie le sommaire plus tard. Sans modification, ces champs n'auraient existé qu'à la
+    /// création, c'est-à-dire jamais.
+    /// </summary>
+    [Fact]
+    public async Task Un_numero_apprend_sa_une_apres_coup()
+    {
+        var revue = await RevueAsync();
+        var cree = (await _revues.AjouterNumeroAsync(
+            revue.Id, new AjoutNumeroRevue { Numero = "43" })).Revue!;
+
+        var numeroId = cree.Numeros[0].Id;
+
+        var apres = await _revues.ModifierNumeroAsync(numeroId, new AjoutNumeroRevue
+        {
+            Numero = "43",
+            Articles = ["Le retour du train de nuit"],
+        });
+
+        Assert.Equal(["Le retour du train de nuit"], apres.Revue!.Numeros[0].Articles);
+    }
+
+    /// <summary>
+    /// ⚠️ Remplacement et non fusion : la ligne de saisie <b>est</b> la liste. Un titre effacé
+    /// du champ doit disparaître, comme pour les thèmes d'un livre.
+    /// </summary>
+    [Fact]
+    public async Task Reecrire_la_une_remplace_lancienne()
+    {
+        var revue = await RevueAsync();
+        var cree = (await _revues.AjouterNumeroAsync(revue.Id, new AjoutNumeroRevue
+        {
+            Numero = "43",
+            Articles = ["Premier", "Second"],
+        })).Revue!;
+
+        var apres = await _revues.ModifierNumeroAsync(
+            cree.Numeros[0].Id, new AjoutNumeroRevue { Numero = "43", Articles = ["Troisième"] });
+
+        Assert.Equal(["Troisième"], apres.Revue!.Numeros[0].Articles);
+        Assert.Single(await _db.ArticlesUne.ToListAsync());
+    }
+
+    [Fact]
+    public async Task Retirer_le_numero_emporte_sa_une()
+    {
+        var revue = await RevueAsync();
+        var cree = (await _revues.AjouterNumeroAsync(revue.Id, new AjoutNumeroRevue
+        {
+            Numero = "43",
+            Articles = ["Ukraine, deux ans après"],
+        })).Revue!;
+
+        Assert.True(await _revues.RetirerNumeroAsync(cree.Numeros[0].Id));
+
+        // Cascade : un article à la une n'existe que par la parution qui le porte.
+        Assert.Empty(await _db.ArticlesUne.ToListAsync());
+    }
+
+    /// <summary>
+    /// L'unicité <c>(NumeroRevueId, TitreNormalise)</c> vit en base : un doublon envoyé
+    /// directement à l'API ferait échouer l'écriture si le service ne l'écartait pas.
+    /// </summary>
+    [Fact]
+    public async Task Le_meme_article_ne_sannonce_pas_deux_fois()
+    {
+        var revue = await RevueAsync();
+
+        var apres = await _revues.AjouterNumeroAsync(revue.Id, new AjoutNumeroRevue
+        {
+            Numero = "43",
+            Articles = ["Ukraine, deux ans après", "ukraine, DEUX ans après", "  "],
+        });
+
+        Assert.Equal(["Ukraine, deux ans après"], apres.Revue!.Numeros[0].Articles);
+    }
+
+    [Fact]
+    public async Task Deux_numeros_peuvent_titrer_pareil()
+    {
+        var revue = await RevueAsync();
+
+        await _revues.AjouterNumeroAsync(revue.Id, new AjoutNumeroRevue
+        {
+            Numero = "43",
+            Articles = ["Le dossier de l'année"],
+        });
+
+        var apres = await _revues.AjouterNumeroAsync(revue.Id, new AjoutNumeroRevue
+        {
+            Numero = "44",
+            Articles = ["Le dossier de l'année"],
+        });
+
+        // L'unicité est bornée au numéro : deux parutions peuvent parfaitement titrer pareil.
+        Assert.Null(apres.Erreur);
+        Assert.Equal(2, (await _db.ArticlesUne.ToListAsync()).Count);
+    }
+
     public void Dispose()
     {
         _db.Dispose();