> 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/es/aplicaciones/interaction.md).

# Interacción

Universal Apps permite crear sitios web interactivos con PowerShell. Se han implementado varios cmdlets para proporcionar información al usuario, actualizar componentes y leer el estado de los componentes.

## Portapapeles

Puede establecer datos de cadena en el portapapeles del usuario con `Set-UDClipboard`.

```powershell
New-UDButton -Text 'Clipboard' -OnClick {
    Set-UDClipboard -Data 'Hello, there!'
}
```

#### API

* [Set-UDClipboard](/powershell-universal/es/comandos-de-powershell/set-udclipboard.md)

## Descargas

Puede iniciar una descarga en el navegador del usuario mediante `Start-UDDownload`. Debido a la seguridad de los navegadores web, el usuario deberá realizar una acción (como hacer clic en un botón) para permitir que la descarga se lleve a cabo. `Start-UDDownload` no es adecuado para descargas de ficheros grandes.

```powershell
New-UDButton -Text 'Download' -OnClick {
    Start-UDDownload -StringData 'Hello, World!'
}
```

## Controladores de eventos

Muchos componentes admiten controladores de eventos en forma de bloques de script. También puede verlos denominados endpoints, ya que así se llamaban en Universal Dashboard v2. Estos controladores de eventos permiten invocar scripts de PowerShell cuando se producen determinadas acciones en la página.

Por ejemplo, puede tener un clic de botón que llame a un controlador de eventos. Este botón mostrará un toast al hacer clic. Puede incluir cualquier cmdlet válido de PowerShell dentro del código del controlador de eventos.

```powershell
New-UDButton -Text 'Click Me' -OnClick {
   Show-UDToast 'Hello!'
}
```

### Ámbito de las variables

Las variables se incluyen automáticamente en el ámbito de los controladores de eventos. Podrá acceder a las variables que defina fuera de la variable dentro del controlador de eventos.

```powershell
$MyVariable = "Hello!"
New-UDButton -Text 'Click Me' -OnClick {
   Show-UDToast $MyVariable
}
```

### Datos del evento

Algunos controladores de eventos proporcionarán datos como una cadena o como una tabla hash. Esto depende del controlador de eventos que esté utilizando. Por ejemplo, el controlador de eventos `-OnClick` de `New-UDButton` no proporciona ningún dato. Por otro lado, `-OnChange` de `New-UDSelect` sí proporcionará datos del evento.

Puede acceder a los datos del evento usando la variable `$Body` para obtener los datos como una cadena (a veces con formato JSON) o como una tabla hash usando la variable `$EventData`.

```powershell
New-UDSelect -Option {
    New-UDSelectOption -Name 'One' -Value 1
    New-UDSelectOption -Name 'Two' -Value 2
    New-UDSelectOption -Name 'Three' -Value 3
} -OnChange { Show-UDToast -Message $EventData }
```

## Formularios

### Enviar un formulario

Puede forzar el envío de un formulario mediante el cmdlet `Invoke-UDForm`. Opcionalmente, puede elegir aplicar la validación incluyendo el parámetro `-Validate`.

```powershell
New-UDForm -Id 'form' -Content {
   New-UDTextbox -Id 'Text' -Label 'Submit Me'
} -OnSubmit {
   Show-UDToast "Hello!"
}

New-UDButton -Text "Submit Form" -OnClick {
   Invoke-UDForm -Id 'form'
}
```

### Validar un formulario

Puede forzar la validación de un formulario mediante `Test-UDForm`.

```powershell
New-UDForm -Id 'form' -Content {
   New-UDTextbox -Id 'Text' -Label 'Submit Me'
} -OnSubmit {
   Show-UDToast "Hello!"
} -OnValidate {
   New-UDValidationResult
}

New-UDButton -Text "Submit Form" -OnClick {
   Test-UDForm -Id 'form'
}
```

## JavaScript

Puede invocar JavaScript desde PowerShell mediante el cmdlet `Invoke-UDJavaScript`.

```powershell
New-UDButton -Text 'Alert Me' -OnClick {
    Invoke-UDJavaScript -JavaScript 'alert("Hello!")'
}
```

#### **API**

* [Invoke-UDJavaScript](/powershell-universal/es/comandos-de-powershell/invoke-udjavascript.md)

## Toast

### Mostrar un toast

Puede usar el cmdlet `Show-UDToast` para crear un mensaje toast que aparecerá en la página web del usuario final. Se produce a través de un websocket y mostrará el toast inmediatamente cuando se llama.

```powershell
Show-UDToast -Message 'Hello, World!'
```

### Mostrar un toast con un icono

Los toasts admiten iconos como cadenas. Puede usar todos los iconos de FontAwesome v5.

```powershell
Show-UDToast -Icon "Ad" -Message "Test"
```

### Ocultar un toast

Oculta un toast según el ID especificado.

```powershell
Show-UDToast -Message 'Hello, World!' -Id 'Toast' -Duration 30000

New-UDButton -Text 'Click' -OnClick {
    Hide-UDToast -Id 'Toast'
}
```

### API

* [Show-UDToast](/powershell-universal/es/comandos-de-powershell/show-udtoast.md)
* [Hide-UDToast](/powershell-universal/es/comandos-de-powershell/hide-udtoast.md)

## Redirección

Puede redirigir a los usuarios a diferentes páginas mediante el cmdlet `Invoke-UDRedirect`. Se produce a través de un websocket y redirigirá en cuanto se llame al cmdlet.

```powershell
Invoke-UDRedirect http://www.ironmansoftware.com
```

`Invoke-UDRedirect` redirigirá automáticamente a las páginas del dashboard cuando se utiliza una ruta relativa.

```powershell
Invoke-UDRedirect '/page1' 
```

Si desea redirigir a una ruta local fuera del dashboard, puede usar el parámetro `-Native`.

```powershell
Invoke-UDRedirect '/publishedFolder/test.txt' -Native
```

#### API

* [Invoke-UDRedirect](/powershell-universal/es/comandos-de-powershell/invoke-udredirect.md)

## Modal

Puede abrir un modal mediante el cmdlet `Show-UDModal`. Se abrirá en cuanto lo llame. Puede incluir los componentes que desee dentro del modal.

Lea más sobre [los modales aquí](/powershell-universal/es/aplicaciones/components/feedback/modal.md).

## Gestión del estado de los componentes

Puede gestionar el estado de los componentes de forma dinámica mediante los comandos UDElement.

### Obtener el estado de un componente

Puede recibir el estado de un elemento mediante `Get-UDElement` . El estado se devolverá como una tabla hash. Esto resulta especialmente útil para los componentes de entrada.

```powershell
$Value = (Get-UDElement -Id 'txtExample').value
```

### Establecer el estado de un componente

Como alternativa, puede establecer el estado de un componente mediante `Set-UDElement` . Deberá especificar un ID y una tabla hash de propiedades que establecer en el componente. Todos los componentes integrados admiten Set-UDElement.

```powershell
New-UDTextbox -Id 'textbox'

New-UDButton -Text 'Click' -OnClick {
    Set-UDElement -Id 'textbox' -Properties @{
        Value = 'My Value'
    }
}
```

### Eliminar un componente

Puede eliminar componentes de la página mediante `Remove-UDElement` . El componente ya no aparecerá en la página.

```powershell
Remove-UDComponent -Id 'txtExample'
```

### Añadir un componente

Añada un componente secundario a un componente principal existente.

```powershell
New-UDElement -Id 'myDiv' -Tag div

New-UDButton -Text 'Click' -OnClick {
    Add-UDElement -ParentId 'myDiv' -Content {
        New-UDTypography -Text 'Hi'
    }
}
```

### Vaciar un componente

Puede eliminar todos los componentes secundarios de un componente mediante `Clear-UDElement`.

```powershell
New-UDElement -Id 'myDiv' -Tag div

New-UDButton -Text 'Click' -OnClick {
    Add-UDElement -ParentId 'myDiv' -Content {
        New-UDTypography -Text 'Hi'
    }
    Add-UDElement -ParentId 'myDiv' -Content {
        New-UDTypography -Text 'Hi'
    }
    Add-UDElement -ParentId 'myDiv' -Content {
        New-UDTypography -Text 'Hi'
    }
}

New-UDButton -Text 'Clear' -OnClick {
    Clear-UDElement -Id 'myDiv'
}
```

### Recargar un componente

Algunos componentes admiten la recarga. Puede activar la recarga de un componente mediante `Sync-UDElement`.

```powershell
New-UDDynamic -Id 'reloadMe' -Content {
    Get-Date
}

New-UDButton -Text 'Reload' -OnClick {
    Sync-UDElement -Id 'reloadMe'
}
```

### Seleccionar un componente

Puede seleccionar un componente con `Select-UDElement`.

```powershell
New-UDElement -Id 'txt' -Tag input -Properties @{ type = text }

New-UDButton -Text 'Select' -OnClick {
    Select-UDElement -Id 'txt' -ScrollToElement
}
```

## Integración con el host de PowerShell

Los dashboards se integran directamente con el host de PowerShell para proporcionar funciones basadas en cmdlets estándar.

### Read-Host

El uso del cmdlet `Read-Host` provocará que se muestre un cuadro de diálogo en el dashboard del usuario. El texto introducido será devuelto por el cmdlet.

```powershell
$Text = Read-Host 'Enter Some Text'
Show-UDToast $Text
```

<figure><img src="/files/37wqA35hQDLK5jwcWtTN" alt=""><figcaption></figcaption></figure>

### Get-Credential

El uso de `Get-Credential` provocará que se muestre un cuadro de diálogo que acepta un nombre de usuario y una contraseña. El cmdlet devolverá un objeto `PSCredential`.

```powershell
Get-Credential -UserName "adam"
```

<figure><img src="/files/HJriPpCpQ6X2889v0HrK" alt=""><figcaption></figcaption></figure>

### Write-Progress

Los cmdlets que usan el flujo de progreso o el uso del cmdlet `Write-Progress` darán como resultado que se muestre un cuadro de diálogo de progreso. La ventana emergente mostrará la actividad, el porcentaje completado y la operación actual.

```powershell
1..100 | ForEach-Object {
    Write-Progress -PercentComplete $_ -Activity 'Processing...' -CurrentOperation "User $_"
    Start-Sleep -Milliseconds 500
}
```

<figure><img src="/files/csmeohdMG9wJygsvhA0u" alt=""><figcaption></figcaption></figure>

Puede desactivar la integración de Write-Progress estableciendo `$ProgressPreference` en `SilentlyContinue`.

```powershell
$ProgressPreference = 'SilentlyContinue'
```

### Solicitar una elección

Puede usar la función `$Host.UI.PromptForChoice` para mostrar un cuadro de diálogo de selección múltiple.

```powershell
$Title = "Welcome"
$Info = "Just to Demo Prompt for Choice"

$options = [System.Management.Automation.Host.ChoiceDescription[]] @("Power", "Shell", "Quit")
[int]$defaultchoice = 2
$opt = $host.UI.PromptForChoice($Title , $Info , $Options, $defaultchoice)
switch ($opt) {
    0 { Show-UDToast "Power" }
    1 { Show-UDToast "Shell" }
    2 { Show-UDToast "Good Bye!!!" }
}
```

<figure><img src="/files/xdvrhcSkRgR31lCPwQGF" alt=""><figcaption></figcaption></figure>

### Write-Host

`Write-Host` dentro de las aplicaciones escribirá en la pestaña Log de la Admin Console de la aplicación. Si desea recibir estos mensajes de registro en la consola de su navegador en las Herramientas para desarrolladores, puede activar el registro en la consola en appsettings.json.

```json
{
    "UniversalDashboard": {
        "ConsoleLog": true
    }
}
```

## API

* [Get-UDElement](/powershell-universal/es/comandos-de-powershell/get-udelement.md)
* [Set-UDElement](/powershell-universal/es/comandos-de-powershell/set-udelement.md)
* [Clear-UDElement](/powershell-universal/es/comandos-de-powershell/clear-udelement.md)
* [Remove-UDElement](/powershell-universal/es/comandos-de-powershell/remove-udelement.md)
* [Sync-UDElement](/powershell-universal/es/comandos-de-powershell/sync-udelement.md)
* [Select-UDElement](/powershell-universal/es/comandos-de-powershell/select-udelement.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/es/aplicaciones/interaction.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.
