> For the complete documentation index, see [llms.txt](https://docs.devolutions.net/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.devolutions.net/powershell-universal/fr/applis/components/inputs/form.md).

# Formulaire

Créez des formulaires dans les applis PowerShell Universal qui recueillent, valident et soumettent des données provenant de zones de texte, de cases à cocher, de sélecteurs et d'autres contrôles d'ent

{% embed url="<https://youtu.be/o8Bl1NsCc2Y>" %}

Les formulaires offrent un moyen de recueillir des données auprès des utilisateurs.

Les formulaires peuvent inclure tout type de contrôle de votre choix. Cela vous permet de personnaliser l'apparence et d'utiliser n'importe quel contrôle d'entrée.

Les données saisies via les contrôles d'entrée seront renvoyées au bloc de script `OnSubmit` lorsque le formulaire est soumis. Dans le gestionnaire d'événements `OnSubmit`, vous aurez accès à la variable `$EventData` qui contiendra des propriétés pour chacun des champs du formulaire.

Par exemple, si vous avez deux champs, vous aurez deux propriétés sur `$EventData`.

```powershell
New-UDForm -Content {
    New-UDTextbox -Id 'txtTextField'
    New-UDCheckbox -Id 'chkCheckbox'
} -OnSubmit {
    Show-UDToast -Message $EventData.txtTextField
    Show-UDToast -Message $EventData.chkCheckbox
}
```

## Contrôles pris en charge

Les contrôles d'entrée suivants s'intègrent automatiquement à un formulaire. Les valeurs définies dans ces contrôles seront envoyées lors de la validation et dans le gestionnaire d'événements `OnSubmit`.

* [Autocomplete](/powershell-universal/fr/applis/components/inputs/automcomplete.md)
* [Checkbox](/powershell-universal/fr/applis/components/inputs/checkbox.md)
* [Date Picker](/powershell-universal/fr/applis/components/inputs/date-picker.md)
* [Radio](/powershell-universal/fr/applis/components/inputs/radio.md)
* [Select](/powershell-universal/fr/applis/components/inputs/select.md)
* [Slider](/powershell-universal/fr/applis/components/inputs/slider.md)
* [Switch](/powershell-universal/fr/applis/components/inputs/switch.md)
* [Textbox](/powershell-universal/fr/applis/components/inputs/textbox.md)
* [Time Picker](/powershell-universal/fr/applis/components/inputs/time-picker.md)
* [Transfer List](/powershell-universal/fr/applis/components/inputs/transfer-list.md)
* [Upload](/powershell-universal/fr/applis/components/inputs/upload.md)

## Formulaire simple

Les formulaires simples peuvent utiliser des entrées comme des zones de texte et des cases à cocher.

```powershell
New-UDForm -Content {
    New-UDTextbox -Id 'txtTextfield'
    New-UDCheckbox -Id 'chkCheckbox'
} -OnSubmit {
    Show-UDToast -Message $EventData.txtTextfield
    Show-UDToast -Message $EventData.chkCheckbox
}
```

## Mise en forme d'un formulaire

Puisque les formulaires peuvent utiliser n'importe quel composant, vous pouvez utiliser des composants de mise en forme standard dans le formulaire.

```powershell
New-UDForm -Content {

    New-UDRow -Columns {
        New-UDColumn -SmallSize 6 -LargeSize 6 -Content {
            New-UDTextbox -Id 'txtFirstName' -Label 'First Name' 
        }
        New-UDColumn -SmallSize 6 -LargeSize 6 -Content {
            New-UDTextbox -Id 'txtLastName' -Label 'Last Name'
        }
    }

    New-UDTextbox -Id 'txtAddress' -Label 'Address'

    New-UDRow -Columns {
        New-UDColumn -SmallSize 6 -LargeSize 6  -Content {
            New-UDTextbox -Id 'txtState' -Label 'State'
        }
        New-UDColumn -SmallSize 6 -LargeSize 6  -Content {
            New-UDTextbox -Id 'txtZipCode' -Label 'ZIP Code'
        }
    }

} -OnSubmit {
    Show-UDToast -Message $EventData.txtFirstName
    Show-UDToast -Message $EventData.txtLastName
}
```

## Retourner des composants

Lorsqu'un formulaire est soumis, vous pouvez optionnellement retourner un autre composant pour remplacer le formulaire sur la page. Vous pouvez retourner n'importe quel composant Universal Dashboard. Tout ce que vous avez à faire est de vous assurer que le composant est écrit dans le pipeline dans le gestionnaire d'événements `OnSubmit`.

```powershell
New-UDForm -Content {
    New-UDTextbox -Id 'txtTextfield'
} -OnSubmit {
    New-UDTypography -Text $EventData.txtTextfield
}
```

## Valider un formulaire

La validation d'un formulaire peut être réalisée en utilisant le paramètre de bloc de script OnValidate.

```powershell
New-UDForm -Content {
    New-UDTextbox -Id 'txtValidateForm'
} -OnValidate {
    $FormContent = $EventData

    if ($FormContent.txtValidateForm -eq $null -or $FormContent.txtValidateForm -eq '') {
        New-UDFormValidationResult -ValidationError "txtValidateForm is required"
    } else {
        New-UDFormValidationResult -Valid
    }
} -OnSubmit {
    Show-UDToast -Message $Body
}
```

## Annuler un formulaire

Vous pouvez définir un gestionnaire d'événements `-OnCancel` à invoquer lorsque le bouton d'annulation est pressé. Cela peut être utilisé pour effectuer des actions comme fermer une fenêtre modale.

```powershell
New-UDButton -Text 'On Form' -OnClick {
    Show-UDModal -Content {
        New-UDForm -Content {
            New-UDTextbox -Label 'Hello'
        } -OnSubmit {
            Show-UDToast -Message 'Submitted!'
            Hide-UDModal
        } -OnCancel {
            Hide-UDModal
        }
    }
}
```

## Afficher la sortie sans remplacer le formulaire

Bien que vous puissiez retourner des composants directement depuis un formulaire, vous voudrez peut-être conserver le formulaire pour que les utilisateurs puissent saisir des données à nouveau. Pour ce faire, vous pouvez utiliser `Set-UDElement` et un élément d'espace réservé dont vous pouvez définir le contenu.

Dans cet exemple, nous avons un formulaire vide qui, lorsqu'il est soumis, mettra à jour l'élément `results` avec un UDCard.

```powershell
New-UDForm -Content {

} -OnSubmit {
   Set-UDElement -Id 'results' -Content {
      New-UDCard -Content { "Hello " + (Get-Date) }
   }
}

New-UDElement -Id 'results' -Tag 'div'
```

## Formulaires de schéma

Au lieu de définir toute la disposition et la logique des formulaires à l'aide d'applets de commande, vous pouvez également définir un formulaire basé sur une table de hachage de schéma. Cette version des formulaires est basée sur [react-jsonschema-form](https://rjsf-team.github.io/react-jsonschema-form/docs/).

### Champs

Vous définissez des champs qui acceptent les types chaîne, nombre, entier, enum et booléen. Cela change le type d'entrée affiché.

```powershell
New-UDForm -Schema @{
   title = "Test Form"
   type = "object"
   properties = @{
       name = @{
           type = "string"
       }
       age = @{
           type = "number"
       }
   }
} -OnSubmit {
   # $EventData.name
   # $EventData.age
}
```

### Propriétés requises

Vous pouvez utiliser la propriété `required` pour définir une liste de propriétés requises.

```powershell
New-UDForm -Schema @{
   title = "Test Form"
   type = "object"
   properties = @{
       name = @{
           type = "string"
       }
       age = @{
           type = "number"
       }
   }
   required = @('name')
} -OnSubmit {
   # $EventData.name
   # $EventData.age
}
```

{% hint style="warning" %}
Notez que les propriétés doivent être en minuscules! Par exemple, vous devez vous assurer que les clés dans votre table de hachage de propriétés sont en minuscules et que la liste des propriétés requises est également en minuscules.
{% endhint %}

### Ordre

Vous pouvez utiliser la propriété `schemaUI` pour modifier l'ordre des champs.

```powershell
New-UDForm -Schema @{
        title = "Test"
        type = "object"
        properties = @{
            hostname = @{
                title = "Hostname"
                type = "string"
                }
            ipaddress= @{
                title = "IP Address"
                type = "string"
                format = "ipv4"
                }
            description = @{
                title = "Server Description"
                type = "string"
                }
            servertype = @{
                title = "Server Type"
                type = "string"                            
                enum = "App","DB"
                }
            environment = @{
                title = "Environment"
                type = "string"
                enum = "Prod", "Dev" , "QA"
                }
            }
		required = @('hostname','ipaddress','description','servertype','environment')                    
	} -uiSchema @{
		"ui:order" = @('environment','hostname','ipaddress','description')
	} -OnSubmit {
		Show-UDModal -Content {                        
			New-UDTypography -Text $EventData
		} -Footer {
			New-UDButton -Text "Close" -OnClick {Hide-UDModal}
		} -Persistent
	}
```

### Tableaux

Vous pouvez créer des formulaires qui acceptent de 0 à plusieurs objets. L'utilisateur pourra ajouter et retirer des objets du formulaire.

```powershell
New-UDForm -Schema @{
   title = "Test Form"
   type = "array"
   items = @{
      type = "object" 
       properties = @{
           name = @{
               type = "string"
           }
           age = @{
               type = "number"
           }
       }
   }
} -OnSubmit {
   # $EventData[0].name
   # $EventData[0].age
}
```

## Formulaires de script

Vous pouvez générer automatiquement des formulaires basés sur des scripts dans votre environnement PowerShell Universal. Les formulaires de script généreront des composants d'entrée basés sur le bloc `param`. Les formulaires de script prennent automatiquement en charge la progression et la rétroaction.

Les formulaires de script prennent également en charge l'affichage de la sortie sous forme de texte ou de tableau.

```powershell
New-UDForm -Script "Script.ps1" -OutputType 'text'
```

## API

* [New-UDForm](/powershell-universal/fr/commandes-powershell/new-udform.md)
* [New-UDFormValidationResult](/powershell-universal/fr/commandes-powershell/new-udvalidationresult.md)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.devolutions.net/powershell-universal/fr/applis/components/inputs/form.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.