---
sidebar_position: 5
title: Création du modèle d'ajout
---

## Modèle d'ajout

Afin d'ajouter un element nous allons créer un objet représentant notre item.

Pour cela dans créer une nouvelle classe `Models/ItemModel.cs`, cette classe comprendra l'ensemble des informations de notre objet de l'API.

Nous allons aussi ajouter une propriété afin que l'utilisation accepte les conditions d'ajout.

De même des annotations seront présentent afin de valider les champs de notre formulaires.

```csharp title="Models/ItemModel.cs"
public class ItemModel
{ 
	public int Id { get; set; }
	
	[Required]
	[StringLength(50, ErrorMessage = "Le nom affiché ne doit pas dépasser 50 caractères.")]
	public string DisplayName { get; set; }

	[Required]
	[StringLength(50, ErrorMessage = "Le nom ne doit pas dépasser 50 caractères.")]
    [RegularExpression(@"^[a-z''-'\s]{1,40}$", ErrorMessage = "Seulement les caractères en minuscule sont acceptées.")]
	public string Name { get; set; }

	[Required]
    [Range(1, 64)]
	public int StackSize { get; set; }

	[Required]
    [Range(1, 125)]
	public int MaxDurability { get; set; }

	public List<string> EnchantCategories { get; set; }
	
	public List<string> RepairWith { get; set; }
	
	[Required]
	[Range(typeof(bool), "true", "true", ErrorMessage = "Vous devez accepter les conditions.")]
	public bool AcceptCondition { get; set; }

	[Required(ErrorMessage = "L'image de l'item est obligatoire !")]
	public byte[] ImageContent { get; set; }
}
```

## Notion : Data Annotation

### Attributs de validation

Les attributs de validation vous permettent de spécifier des règles de validation pour des propriétés de modèle. 

L’exemple suivant montre une classe de modèle qui est annotée avec des attributs de validation. 
L’attribut `[ClassicMovie]` est un attribut de validation personnalisé, et les autres sont prédéfinis. 

```csharp
public class Movie
{
    public int Id { get; set; }

    [Required]
    [StringLength(100)]
    public string Title { get; set; }

    [ClassicMovie(1960)]
    [DataType(DataType.Date)]
    [Display(Name = "Release Date")]
    public DateTime ReleaseDate { get; set; }

    [Required]
    [StringLength(1000)]
    public string Description { get; set; }

    [Range(0, 999.99)]
    public decimal Price { get; set; }

    public Genre Genre { get; set; }

    public bool Preorder { get; set; }
}
```

### Attributs prédéfinis

Voici certains des attributs de validation prédéfinis :
* `[ValidateNever]`: ValidateNeverAttribute Indique qu’une propriété ou un paramètre doit être exclu de la validation.
* `[CreditCard]`: Vérifie que la propriété a un format de carte de crédit. Requiert des méthodes supplémentaires de validation jQuery.
* `[Compare]`: Valide que deux propriétés d’un modèle correspondent.
* `[EmailAddress]`: Vérifie que la propriété a un format d’e-mail.
* `[Phone]`: Vérifie que la propriété a un format de numéro de téléphone.
* `[Range]`: Vérifie que la valeur de la propriété est comprise dans une plage spécifiée.
* `[RegularExpression]`: Valide le fait que la valeur de propriété corresponde à une expression régulière spécifiée.
* `[Required]`: Vérifie que le champ n’a pas la valeur null. Pour plus d’informations sur le comportement de cet attribut, consultez [Required] attribut .
* `[StringLength]`: Valide le fait qu’une valeur de propriété de type chaîne ne dépasse pas une limite de longueur spécifiée.
* `[Url]`: Vérifie que la propriété a un format d’URL.
* `[Remote]`: Valide l’entrée sur le client en appelant une méthode d’action sur le serveur. Pour plus d’informations sur le comportement de cet attribut, consultez [Remote] attribut .

Vous trouverez la liste complète des attributs de validation dans l’espace de noms [System.ComponentModel.DataAnnotations](https://docs.microsoft.com/fr-fr/dotnet/api/system.componentmodel.dataannotations).

### Messages d’erreur

Les attributs de validation vous permettent de spécifier le message d’erreur à afficher pour l’entrée non valide. Par exemple :

```csharp
[StringLength(8, ErrorMessage = "Name length can't be more than 8.")]
```

En interne, les attributs appellent `String.Format` avec un espace réservé pour le nom de champ et parfois d’autres espaces réservés. Par exemple :

```csharp
[StringLength(8, ErrorMessage = "{0} length must be between {2} and {1}.", MinimumLength = 6)]
```

Appliqué à une propriété `Name`, le message d’erreur créé par le code précédent serait « Name length must be between 6 and 8 ».

Pour savoir quels paramètres sont passés à `String.Format` pour le message d’erreur d’un attribut particulier, consultez le [code source de DataAnnotations](https://github.com/dotnet/runtime/tree/main/src/libraries/System.ComponentModel.Annotations/src/System/ComponentModel/DataAnnotations).

### Attributs personnalisés

Pour les scénarios non gérés par les attributs de validation prédéfinis, vous pouvez créer des attributs de validation personnalisés. Créez une classe qui hérite de ValidationAttribute et substituez la méthode IsValid.

La méthode `IsValid` accepte un objet nommé value, qui est l’entrée à valider. Une surcharge accepte également un objet `ValidationContext`, qui fournit des informations supplémentaires telles que l’instance de modèle créée par la liaison de modèle.

L’exemple suivant vérifie que la date de sortie d’un film appartenant au genre Classic n’est pas ultérieure à une année spécifiée. L'attribut `[ClassicMovie]`:
* S’exécute uniquement sur le serveur.
* Pour les films classiques, valide la date de publication :

```csharp
public class ClassicMovieAttribute : ValidationAttribute
{
    public ClassicMovieAttribute(int year)
    {
        Year = year;
    }

    public int Year { get; }

    public string GetErrorMessage() =>
        $"Classic movies must have a release year no later than {Year}.";

    protected override ValidationResult IsValid(object value,
        ValidationContext validationContext)
    {
        var movie = (Movie)validationContext.ObjectInstance;
        var releaseYear = ((DateTime)value).Year;

        if (movie.Genre == Genre.Classic && releaseYear > Year)
        {
            return new ValidationResult(GetErrorMessage());
        }

        return ValidationResult.Success;
    }
}
```

La variable `movie` de l’exemple précédent représente un objet `Movie` qui contient les données de l’envoi du formulaire. Quand la validation échoue, un `ValidationResult` avec un message d’erreur est retourné.
