astra/ntfy
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

all md files translated to spanish

Browse source 
Signed-off-by: felipe <ingenierofelipeurrego@gmail.com>
This commit is contained in:
felipe 2022-06-23 22:14:35 -05:00
parent bac5e1fa84
commit 6fe00ca4d9
15 changed files with 8574 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

423
docs/subscribe/api-es.md Normal file
View file

@ -0,0 +1,423 @@
# Suscríbete a través de API
Puede crear y suscribirse a un tema en el [interfaz de usuario web](web.md), a través del [aplicación de teléfono](phone.md), a través del [CLI ntfy](cli.md),
o en su propia aplicación o script suscribiéndose a la API. Esta página describe cómo suscribirse a través de api. También es posible que desee
Consulte la página que describe cómo [publicar mensajes](../publish.md).
Puede consumir la API de suscripción como un **[flujo HTTP simple (JSON, SSE o raw)](#http-stream)**o
**[a través de WebSockets](#websockets)**. Ambos son increíblemente simples de usar.
## Flujo HTTP
La API basada en secuencias HTTP se basa en una simple solicitud GET con una respuesta HTTP de transmisión, es decir, **abre una solicitud GET y
La conexión permanece abierta para siempre**, enviando mensajes a medida que entran. Hay tres puntos de enlace de API diferentes, que
sólo difieren en el formato de respuesta:
* [Flujo JSON](#subscribe-as-json-stream): `<topic>/json` devuelve una secuencia JSON, con un objeto de mensaje JSON por línea
* [Flujo de ESS](#subscribe-as-sse-stream): `<topic>/sse` devuelve mensajes como [Eventos enviados por el servidor (SSE)](https://en.wikipedia.org/wiki/Server-sent_events)cuál
se puede utilizar con [Fuente de eventos](https://developer.mozilla.org/en-US/docs/Web/API/EventSource)
* [Flujo raw](#subscribe-as-raw-stream): `<topic>/raw` devuelve mensajes como texto sin formato, con una línea por mensaje
### Suscríbete como transmisión JSON
A continuación se muestran algunos ejemplos de cómo consumir el extremo JSON (`<topic>/json`). Para casi todos los idiomas, **este es el
forma recomendada de suscribirse a un tema**. La excepción notable es JavaScript, para el cual el
[Flujo SSE/EventSource](#subscribe-as-sse-stream) es mucho más fácil trabajar con él.
\=== "Línea de comandos (curl)"
` $ curl -s ntfy.sh/disk-alerts/json
{"id":"SLiKI64DOt","time":1635528757,"event":"open","topic":"mytopic"}
{"id":"hwQ2YpKdmg","time":1635528741,"event":"message","topic":"mytopic","message":"Disk full"}
{"id":"DGUDShMCsc","time":1635528787,"event":"keepalive","topic":"mytopic"}
...
`
\=== "ntfy CLI"
` $ ntfy subcribe disk-alerts
{"id":"hwQ2YpKdmg","time":1635528741,"event":"message","topic":"mytopic","message":"Disk full"}
...
`
\=== "HTTP"
''' http
GET /disk-alerts/json HTTP/1.1
Anfitrión: ntfy.sh
HTTP/1.1 200 OK
Content-Type: application/x-ndjson; charset=utf-8
Transfer-Encoding: chunked
{"id":"SLiKI64DOt","time":1635528757,"event":"open","topic":"mytopic"}
{"id":"hwQ2YpKdmg","time":1635528741,"event":"message","topic":"mytopic","message":"Disk full"}
{"id":"DGUDShMCsc","time":1635528787,"event":"keepalive","topic":"mytopic"}
...
```
\=== "Go"
` go
resp, err := http.Get("https://ntfy.sh/disk-alerts/json")
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
scanner := bufio.NewScanner(resp.Body)
for scanner.Scan() {
println(scanner.Text())
}
`
\=== "Python"
` python
resp = requests.get("https://ntfy.sh/disk-alerts/json", stream=True)
for line in resp.iter_lines():
if line:
print(line)
`
\=== "PHP"
` php-inline
$fp = fopen('https://ntfy.sh/disk-alerts/json', 'r');
if (!$fp) die('cannot open stream');
while (!feof($fp)) {
echo fgets($fp, 2048);
flush();
}
fclose($fp);
`
### Suscríbete como SSE stream
Usando [Fuente de eventos](https://developer.mozilla.org/en-US/docs/Web/API/EventSource) en JavaScript, puede consumir
notificaciones a través de un [Eventos enviados por el servidor (SSE)](https://en.wikipedia.org/wiki/Server-sent_events) corriente. Es increíblemente
fácil de usar. Así es como se ve. También es posible que desee consultar el [ejemplo completo en GitHub](https://github.com/binwiederhier/ntfy/tree/main/examples/web-example-eventsource).
\=== "Línea de comandos (curl)"
\`\`\`
$ curl -s ntfy.sh/mytopic/sse
evento: abierto
datos: {"id":"weSj9RtNkj","time":1635528898,"event":"open","topic":"mytopic"}
data: {"id":"p0M5y6gcCY","time":1635528909,"event":"message","topic":"mytopic","message":"Hi!"}
event: keepalive
data: {"id":"VNxNIg5fpt","time":1635528928,"event":"keepalive","topic":"test"}
...
```
\=== "HTTP"
''' http
OBTENER /mytopic/sse HTTP/1.1
Anfitrión: ntfy.sh
HTTP/1.1 200 OK
Content-Type: text/event-stream; charset=utf-8
Transfer-Encoding: chunked
event: open
data: {"id":"weSj9RtNkj","time":1635528898,"event":"open","topic":"mytopic"}
data: {"id":"p0M5y6gcCY","time":1635528909,"event":"message","topic":"mytopic","message":"Hi!"}
event: keepalive
data: {"id":"VNxNIg5fpt","time":1635528928,"event":"keepalive","topic":"test"}
...
```
\=== "JavaScript"
` javascript
const eventSource = new EventSource('https://ntfy.sh/mytopic/sse');
eventSource.onmessage = (e) => {
console.log(e.data);
};
`
### Suscríbete como flujo raw
El `/raw` El extremo generará una línea por mensaje, y **sólo incluirá el cuerpo del mensaje**. Es útil para extremadamente
scripts simples, y no incluye todos los datos. Campos adicionales como [prioridad](../publish.md#message-priority),
[Etiquetas](../publish.md#tags--emojis--) o [título del mensaje](../publish.md#message-title) no se incluyen en este resultado
formato. Los mensajes de Keepalive se envían como líneas vacías.
\=== "Línea de comandos (curl)"
\`\`\`
$ curl -s ntfy.sh/disk-alerts/raw
Disk full
...
```
\=== "HTTP"
''' http
GET /disk-alerts/raw HTTP/1.1
Anfitrión: ntfy.sh
HTTP/1.1 200 OK
Content-Type: text/plain; charset=utf-8
Transfer-Encoding: chunked
Disk full
...
```
\=== "Go"
` go
resp, err := http.Get("https://ntfy.sh/disk-alerts/raw")
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
scanner := bufio.NewScanner(resp.Body)
for scanner.Scan() {
println(scanner.Text())
}
`
\=== "Python"
` python
resp = requests.get("https://ntfy.sh/disk-alerts/raw", stream=True)
for line in resp.iter_lines():
if line:
print(line)
`
\=== "PHP"
` php-inline
$fp = fopen('https://ntfy.sh/disk-alerts/raw', 'r');
if (!$fp) die('cannot open stream');
while (!feof($fp)) {
echo fgets($fp, 2048);
flush();
}
fclose($fp);
`
## WebSockets
También puede suscribirse a temas a través de [WebSockets](https://en.wikipedia.org/wiki/WebSocket), que también es ampliamente
soportado en muchos idiomas. En particular, webSockets son compatibles de forma nativa en JavaScript. En la línea de comandos,
Recomiendo [websocat](https://github.com/vi/websocat), una herramienta fantástica similar a `socat` o `curl`, pero específicamente
para WebSockets.
El extremo WebSockets está disponible en `<topic>/ws` y devuelve mensajes como objetos JSON similares a los
[Extremo de transmisión JSON](#subscribe-as-json-stream).
\=== "Línea de comandos (websocat)"
` $ websocat wss://ntfy.sh/mytopic/ws
{"id":"qRHUCCvjj8","time":1642307388,"event":"open","topic":"mytopic"}
{"id":"eOWoUBJ14x","time":1642307754,"event":"message","topic":"mytopic","message":"hi there"}
`
\=== "HTTP"
''' http
GET /disk-alerts/ws HTTP/1.1
Anfitrión: ntfy.sh
Actualización: websocket
Conexión: Actualización
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
...
```
\=== "Go"
` go
import "github.com/gorilla/websocket"
ws, _, _ := websocket.DefaultDialer.Dial("wss://ntfy.sh/mytopic/ws", nil)
messageType, data, err := ws.ReadMessage()
...
`
\=== "JavaScript"
` javascript
const socket = new WebSocket('wss://ntfy.sh/mytopic/ws');
socket.addEventListener('message', function (event) {
console.log(event.data);
});
`
## Funciones avanzadas
### Sondeo para mensajes
También puede sondear mensajes si no le gusta la conexión de larga data utilizando el `poll=1`
parámetro de consulta. La conexión finalizará después de que se hayan leído todos los mensajes disponibles. Este parámetro puede ser
combinado con `since=` (el valor predeterminado es `since=all`).
curl -s "ntfy.sh/mytopic/json?poll=1"
### Recuperar mensajes almacenados en caché
Los mensajes pueden almacenarse en caché durante un par de horas (consulte [almacenamiento en caché de mensajes](../config.md#message-cache)) para dar cuenta de la red
interrupciones de suscriptores. Si el servidor ha configurado el almacenamiento en caché de mensajes, puede volver a leer lo que se perdió mediante el uso de
el `since=` parámetro de consulta. Toma una duración (por ejemplo, `10m` o `30s`), una marca de tiempo Unix (por ejemplo, `1635528757`),
un ID de mensaje (por ejemplo, `nFS3knfcQ1xe`), o `all` (todos los mensajes almacenados en caché).
curl -s "ntfy.sh/mytopic/json?since=10m"
curl -s "ntfy.sh/mytopic/json?since=1645970742"
curl -s "ntfy.sh/mytopic/json?since=nFS3knfcQ1xe"
### Recuperar mensajes programados
Mensajes que son [programado para ser entregado](../publish.md#scheduled-delivery) en una fecha posterior no suelen ser
devuelto al suscribirse a través de la API, lo que tiene sentido, porque después de todo, los mensajes técnicamente no han sido
entregado todavía. Para devolver también los mensajes programados de la API, puede utilizar el botón `scheduled=1` (alias: `sched=1`)
(tiene más sentido con el parámetro `poll=1` parámetro):
curl -s "ntfy.sh/mytopic/json?poll=1&sched=1"
### Filtrar mensajes
Puede filtrar qué mensajes se devuelven en función de los campos de mensajes conocidos `id`, `message`, `title`, `priority` y
`tags`. Este es un ejemplo que solo devuelve mensajes de prioridad alta o urgente que contienen las dos etiquetas
"zfs-error" y "error". Tenga en cuenta que el `priority` el filtro es un QUI lógico y el `tags` el filtro es un AND lógico.
$ curl "ntfy.sh/alerts/json?priority=high&tags=zfs-error"
{"id":"0TIkJpBcxR","time":1640122627,"event":"open","topic":"alerts"}
{"id":"X3Uzz9O1sM","time":1640122674,"event":"message","topic":"alerts","priority":4,
"tags":["error", "zfs-error"], "message":"ZFS pool corruption detected"}
Filtros disponibles (todos sin distinción de mayúsculas y minúsculas):
| | de variables de filtro Alias | Ejemplo | Descripción |
|-----------------|---------------------------|-----------------------------------------------|-------------------------------------------------------------------------|
| `id` | `X-ID` | `ntfy.sh/mytopic/json?poll=1&id=pbkiz8SD7ZxG` | Solo devuelve mensajes que coincidan con este ID de mensaje exacto |
| `message` | `X-Message`, `m` | `ntfy.sh/mytopic/json?message=lalala` | Solo devuelve mensajes que coincidan con esta cadena de mensaje exacta |
| `title` | `X-Title`, `t` | `ntfy.sh/mytopic/json?title=some+title` | Solo devuelve mensajes que coincidan con esta cadena de título exacta |
| `priority` | `X-Priority`, `prio`, `p` | `ntfy.sh/mytopic/json?p=high,urgent` | Solo devuelve mensajes que coinciden *cualquier prioridad enumerada* | (separados por comas)
| `tags` | `X-Tags`, `tag`, `ta` | `ntfy.sh/mytopic?/jsontags=error,alert` | Solo devuelve mensajes que coinciden *todas las etiquetas enumeradas* | (separados por comas)
### Suscríbete a varios temas
Es posible suscribirse a varios temas en una llamada HTTP proporcionando una lista de temas separados por comas
en la URL. Esto le permite reducir el número de conexiones que debe mantener:
$ curl -s ntfy.sh/mytopic1,mytopic2/json
{"id":"0OkXIryH3H","time":1637182619,"event":"open","topic":"mytopic1,mytopic2,mytopic3"}
{"id":"dzJJm7BCWs","time":1637182634,"event":"message","topic":"mytopic1","message":"for topic 1"}
{"id":"Cm02DsxUHb","time":1637182643,"event":"message","topic":"mytopic2","message":"for topic 2"}
### Autenticación
Dependiendo de si el servidor está configurado para admitir [control de acceso](../config.md#access-control), algunos temas
puede estar protegido contra lectura/escritura para que solo los usuarios con las credenciales correctas puedan suscribirse o publicar en ellos.
Para publicar/suscribirse a temas protegidos, puede utilizar [Autenticación básica](https://en.wikipedia.org/wiki/Basic_access_authentication)
con un nombre de usuario/contraseña válido. Para su servidor autohospedado, **Asegúrese de usar HTTPS para evitar escuchas** y exponer
su contraseña.
curl -u phil:mypass -s "https://ntfy.example.com/mytopic/json"
## Formato de mensaje JSON
Tanto el [`/json` Extremo](#subscribe-as-json-stream) y el [`/sse` Extremo](#subscribe-as-sse-stream) devolver un JSON
formato del mensaje. Es muy sencillo:
**Mensaje**:
| | de campo | requerido Tipo | Ejemplo | Descripción |
|--------------|----------|---------------------------------------------------|-------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
| `id` | ✔️ | *cuerda* | `hwQ2YpKdmg` | Identificador de mensaje elegido al azar |
| `time` | ✔️ | *número* | `1635528741` | Hora de la fecha del mensaje, como | de la marca de tiempo de Unix\
| `event` | ✔️ | `open`, `keepalive`, `message`o `poll_request` | `message` | Tipo de mensaje, normalmente solo te interesaría `message` |
| `topic` | ✔️ | *cuerda* | `topic1,topic2` | Lista separada por comas de los temas con los que está asociado el mensaje; sólo uno para todos `message` eventos, pero puede ser una lista en `open` | de eventos
| `message` | - | *cuerda* | `Some message` | Cuerpo del mensaje; siempre presente en `message` | de eventos
| `title` | - | *cuerda* | `Some title` | Mensaje [título](../publish.md#message-title); Si no, establezca los valores predeterminados en `ntfy.sh/<topic>` |
| `tags` | - | *matriz de cadenas* | `["tag1","tag2"]` | Lista de [Etiquetas](../publish.md#tags-emojis) que pueden o no asignarse a emojis |
| `priority` | - | *1, 2, 3, 4 o 5* | `4` | Mensaje [prioridad](../publish.md#message-priority) con 1=min, 3=default y 5=max |
| `click` | - | *URL* | `https://example.com` | Sitio web abierto cuando se notifica [Clic](../publish.md#click-action) |
| `actions` | - | *Matriz JSON* | *ver [botones de acciones](../publish.md#action-buttons)* | [Botones de acción](../publish.md#action-buttons) que se puede mostrar en el | de notificación
| `attachment` | - | *Objeto JSON* | *ver más abajo* | Detalles sobre un archivo adjunto (nombre, URL, tamaño, ...) |
**Archivo adjunto** (parte del mensaje, véase [Accesorios](../publish.md#attachments) para más detalles):
| | de campo | requerido Tipo | Ejemplo | Descripción |
|-----------|----------|-------------|--------------------------------|-----------------------------------------------------------------------------------------------------------|
| `name` | ✔️ | *cuerda* | `attachment.jpg` | Nombre del archivo adjunto, se puede anular con `X-Filename`ver [Accesorios](../publish.md#attachments) |
| `url` | ✔️ | *URL* | `https://example.com/file.jpg` | Dirección URL del | adjunto\
| `type` | -️ | *tipo mime* | `image/jpeg` | Tipo mime de los datos adjuntos, solo definido si los datos adjuntos se cargaron en el servidor ntfy |
| `size` | -️ | *número* | `33848` | Tamaño de los datos adjuntos en bytes, solo definido si los datos adjuntos se cargaron en el servidor ntfy |
| `expires` | -️ | *número* | `1635528741` | Fecha de caducidad de los datos adjuntos como marca de tiempo de Unix, solo definida si los datos adjuntos se cargaron en el servidor ntfy |
A continuación se muestra un ejemplo para cada tipo de mensaje:
\=== "Mensaje de notificación"
` json
{
"id": "sPs71M8A2T",
"time": 1643935928,
"event": "message",
"topic": "mytopic",
"priority": 5,
"tags": [
"warning",
"skull"
],
"click": "https://homecam.mynet.lan/incident/1234",
"attachment": {
"name": "camera.jpg",
"type": "image/png",
"size": 33848,
"expires": 1643946728,
"url": "https://ntfy.sh/file/sPs71M8A2T.png"
},
"title": "Unauthorized access detected",
"message": "Movement detected in the yard. You better go check"
}
`
\=== "Mensaje de notificación (mínimo)"
` json
{
"id": "wze9zgqK41",
"time": 1638542110,
"event": "message",
"topic": "phil_alerts",
"message": "Remote access to phils-laptop detected. Act right away."
}
`
\=== "Mensaje abierto"
` json
{
"id": "2pgIAaGrQ8",
"time": 1638542215,
"event": "open",
"topic": "phil_alerts"
}
`
\=== "Mensaje Keepalive"
` json
{
"id": "371sevb0pD",
"time": 1638542275,
"event": "keepalive",
"topic": "phil_alerts"
}
`
\=== "Mensaje de solicitud de sondeo"
` json
{
"id": "371sevb0pD",
"time": 1638542275,
"event": "poll_request",
"topic": "phil_alerts"
}
`
## Lista de todos los parámetros
La siguiente es una lista de todos los parámetros que se pueden pasar **al suscribirse a un mensaje**. Los nombres de los parámetros son **no distingue entre mayúsculas y minúsculas**,
y se puede pasar como **Encabezados HTTP** o **parámetros de consulta en la dirección URL**. Se enumeran en la tabla en su forma canónica.
| | de parámetros Alias (sin distinción entre mayúsculas y minúsculas) | Descripción |
|-------------|----------------------------|---------------------------------------------------------------------------------|
| `poll` | `X-Poll`, `po` | Devolver mensajes almacenados en caché y cerrar | de conexión
| `since` | `X-Since`, `si` | Devolver mensajes almacenados en caché desde la marca de tiempo, la duración o el ID del mensaje |
| `scheduled` | `X-Scheduled`, `sched` | Incluir mensajes programados/retrasados en la lista de |
| `id` | `X-ID` | Filtro: solo devuelve mensajes que coincidan con este ID de mensaje exacto |
| `message` | `X-Message`, `m` | Filtro: solo devuelve mensajes que coincidan con esta cadena de mensaje exacta |
| `title` | `X-Title`, `t` | Filtro: solo devuelve mensajes que coincidan con esta cadena de título exacta |
| `priority` | `X-Priority`, `prio`, `p` | Filtro: solo devuelve mensajes que coinciden *cualquier prioridad enumerada* | (separados por comas)
| `tags` | `X-Tags`, `tag`, `ta` | Filtro: solo devuelve mensajes que coinciden *todas las etiquetas enumeradas* | (separados por comas)

291
docs/subscribe/cli-es.md Normal file
View file

@ -0,0 +1,291 @@
# Suscríbete a través de ntfy CLI
Además de suscribirse a través del [interfaz de usuario web](web.md)el [aplicación de teléfono](phone.md), o el [API](api.md), puedes suscribirte
a los temas a través de la CLI de ntfy. La CLI está incluida en la misma `ntfy` binario que se puede utilizar para [autohospedar un servidor](../install.md).
!!! información
El **La CLI de Ntfy no es necesaria para enviar o recibir mensajes**. En su lugar, puede [enviar mensajes con curl](../publish.md),
e incluso usarlo para [suscribirse a temas](api.md). Puede ser un poco más conveniente usar la CLI ntfy que escribir
tu propio guión. Todo depende del caso de uso. 😀
## Instalar + configurar
Para instalar la CLI de ntfy, simplemente **Siga los pasos descritos en el cuadro de diálogo [página de instalación](../install.md)**. El servidor ntfy y
los clientes son el mismo binario, por lo que todo es muy conveniente. Después de la instalación, puede (opcionalmente) configurar el cliente
creando `~/.config/ntfy/client.yml` (para el usuario no root), o `/etc/ntfy/client.yml` (para el usuario root). Tú
puede encontrar un [configuración de esqueleto](https://github.com/binwiederhier/ntfy/blob/main/client/client.yml) en GitHub.
Si solo quieres usar [ntfy.sh](https://ntfy.sh), no tienes que cambiar nada. Si usted **autohospede su propio servidor**,
Es posible que desee modificar el cuadro de diálogo `default-host` opción:
```yaml
# Base URL used to expand short topic names in the "ntfy publish" and "ntfy subscribe" commands.
# If you self-host a ntfy server, you'll likely want to change this.
#
default-host: https://ntfy.myhost.com
```
## Publicar mensajes
Puede enviar mensajes con la CLI de ntfy mediante el `ntfy publish` (o cualquiera de sus alias) `pub`, `send` o
`trigger`). Hay muchos ejemplos en la página sobre [publicar mensajes](../publish.md), pero aquí hay algunos
rápidos:
\=== "Envío simple"
` ntfy publish mytopic This is a message
ntfy publish mytopic "This is a message"
ntfy pub mytopic "This is a message"
`
\=== "Enviar con título, prioridad y etiquetas"
` ntfy publish \ --title="Thing sold on eBay" \ --priority=high \ --tags=partying_face \
mytopic \
"Somebody just bought the thing that you sell"
`
\=== "Enviar a las 8:30am"
` ntfy pub --at=8:30am delayed_topic Laterzz
`
\=== "Triggering a webhook"
` ntfy trigger mywebhook
ntfy pub mywebhook
`
### Adjuntar un archivo local
Puede cargar y adjuntar fácilmente un archivo local a una notificación:
$ ntfy pub --file README.md mytopic | jq .
{
"id": "meIlClVLABJQ",
"time": 1655825460,
"event": "message",
"topic": "mytopic",
"message": "You received a file: README.md",
"attachment": {
"name": "README.md",
"type": "text/plain; charset=utf-8",
"size": 2892,
"expires": 1655836260,
"url": "https://ntfy.sh/file/meIlClVLABJQ.txt"
}
}
### Espere a PID/comando
Si tiene un comando de ejecución prolongada y desea **Publicar una notificación cuando se complete el comando**,
puede envolverlo con `ntfy publish --wait-cmd` (alias: `--cmd`, `--done`). O, si olvidó envolverlo, y el
El comando ya se está ejecutando, puede esperar a que se complete el proceso con `ntfy publish --wait-pid` (alias: `--pid`).
Ejecute un comando y espere a que se complete (aquí: `rsync ...`):
$ ntfy pub --wait-cmd mytopic rsync -av ./ root@example.com:/backups/ | jq .
{
"id": "Re0rWXZQM8WB",
"time": 1655825624,
"event": "message",
"topic": "mytopic",
"message": "Command succeeded after 56.553s: rsync -av ./ root@example.com:/backups/"
}
O bien, si ya inició el proceso de ejecución prolongada y desea esperarlo con su ID de proceso (PID), puede hacer lo siguiente:
\=== "Usando un PID directamente"
` $ ntfy pub --wait-pid 8458 mytopic | jq .
{
"id": "orM6hJKNYkWb",
"time": 1655825827,
"event": "message",
"topic": "mytopic",
"message": "Process with PID 8458 exited after 2.003s"
}
`
\=== "Usando un `pidof`"
` $ ntfy pub --wait-pid $(pidof rsync) mytopic | jq .
{
"id": "orM6hJKNYkWb",
"time": 1655825827,
"event": "message",
"topic": "mytopic",
"message": "Process with PID 8458 exited after 2.003s"
}
`
## Suscríbete a los temas
Puede suscribirse a temas usando `ntfy subscribe`. Dependiendo de cómo se llame, este comando
imprimirá o ejecutará un comando para cada mensaje que llegue. Hay algunas maneras diferentes
en el que se puede ejecutar el comando:
### Transmitir mensajes como JSON
ntfy subscribe TOPIC
Si ejecuta el comando de esta manera, imprime la representación JSON de cada mensaje entrante. Esto es útil
cuando tiene un comando que desea transmitir y leer mensajes JSON entrantes. A menos que `--poll` se pasa, este comando
permanece abierto para siempre.
$ ntfy sub mytopic
{"id":"nZ8PjH5oox","time":1639971913,"event":"message","topic":"mytopic","message":"hi there"}
{"id":"sekSLWTujn","time":1639972063,"event":"message","topic":"mytopic",priority:5,"message":"Oh no!"}
...
<figure>
<video controls muted autoplay loop width="650" src="../../static/img/cli-subscribe-video-1.mp4"></video>
<figcaption>Subscribe in JSON mode</figcaption>
</figure>
### Ejecutar comando para cada mensaje
ntfy subscribe TOPIC COMMAND
Si lo ejecuta de esta manera, se ejecuta un COMANDO para cada mensaje entrante. Desplácese hacia abajo para ver una lista de disponibles
variables de entorno. Aquí hay algunos ejemplos:
ntfy sub mytopic 'notify-send "$m"'
ntfy sub topic1 /my/script.sh
ntfy sub topic1 'echo "Message $m was received. Its title was $t and it had priority $p'
<figure>
<video controls muted autoplay loop width="650" src="../../static/img/cli-subscribe-video-2.webm"></video>
<figcaption>Execute command on incoming messages</figcaption>
</figure>
Los campos de mensaje se pasan al comando como variables de entorno y se pueden utilizar en scripts. Tenga en cuenta que desde
Estas son variables de entorno, normalmente no tiene que preocuparse por citar demasiado, siempre y cuando las incluya
entre comillas dobles, debería estar bien:
| | variable Alias | Descripción |
|------------------|----------------------------|----------------------------------------|
| `$NTFY_ID` | `$id` | Identificador de mensaje único |
| `$NTFY_TIME` | `$time` | Marca de tiempo Unix del | de entrega de mensajes
| `$NTFY_TOPIC` | `$topic` | Nombre del tema |
| `$NTFY_MESSAGE` | `$message`, `$m` | | del cuerpo del mensaje
| `$NTFY_TITLE` | `$title`, `$t` | Título del mensaje |
| `$NTFY_PRIORITY` | `$priority`, `$prio`, `$p` | Prioridad del mensaje (1=min, 5=max) |
| `$NTFY_TAGS` | `$tags`, `$tag`, `$ta` | Etiquetas de mensaje (lista separada por comas) |
| `$NTFY_RAW` | `$raw` | | de mensajes JSON sin procesar
### Suscríbete a varios temas
ntfy subscribe --from-config
Para suscribirse a varios temas a la vez y ejecutar diferentes comandos para cada uno, puede usar `ntfy subscribe --from-config`,
que leerá el `subscribe` config desde el archivo de configuración. Por favor, echa un vistazo también a la [Servicio systemd ntfy-client](#using-the-systemd-service).
Aquí hay un archivo de configuración de ejemplo que se suscribe a tres temas diferentes, ejecutando un comando diferente para cada uno de ellos:
\=== "~/.config/ntfy/client.yml (Linux)"
` yaml
subscribe: - topic: echo-this
command: 'echo "Message received: $message"' - topic: alerts
command: notify-send -i /usr/share/ntfy/logo.png "Important" "$m"
if:
priority: high,urgent - topic: calc
command: 'gnome-calculator 2>/dev/null &' - topic: print-temp
command: |
echo "You can easily run inline scripts, too."
temp="$(sensors | awk '/Pack/ { print substr($4,2,2) }')"
if [ $temp -gt 80 ]; then
echo "Warning: CPU temperature is $temp. Too high."
else
echo "CPU temperature is $temp. That's alright."
fi
`
\=== "~/Library/Application Support/ntfy/client.yml (macOS)"
` yaml
subscribe: - topic: echo-this
command: 'echo "Message received: $message"' - topic: alerts
command: osascript -e "display notification \"$message\""
if:
priority: high,urgent - topic: calc
command: open -a Calculator
`
\=== "%AppData%\ntfy\client.yml (Windows)"
` yaml
subscribe: - topic: echo-this
command: 'echo Message received: %message%' - topic: alerts
command: |
notifu /m "%NTFY_MESSAGE%"
exit 0
if:
priority: high,urgent - topic: calc
command: calc
`
En este ejemplo, cuando `ntfy subscribe --from-config` se ejecuta:
* Mensajes a `echo-this` simplemente hace eco a la salida estándar
* Mensajes a `alerts` Mostrar como notificación de escritorio para mensajes de alta prioridad mediante [notificar-enviar](https://manpages.ubuntu.com/manpages/focal/man1/notify-send.1.html) (Linux),
[notifu](https://www.paralint.com/projects/notifu/) (Ventanas) o `osascript` (macOS)
* Mensajes a `calc` abra la calculadora 😀 (*porque, ¿por qué no?*)
* Mensajes a `print-temp` Ejecute un script en línea e imprima la temperatura de la CPU (solo versión de Linux)
Espero que esto muestre cuán poderoso es este comando. Aquí hay un breve video que demuestra el ejemplo anterior:
<figure>
<video controls muted autoplay loop width="650" src="../../static/img/cli-subscribe-video-3.webm"></video>
<figcaption>Execute all the things</figcaption>
</figure>
### Uso del servicio systemd
Puede utilizar el `ntfy-client` servicio systemd (consulte [ntfy-client.service](https://github.com/binwiederhier/ntfy/blob/main/client/ntfy-client.service))
para suscribirse a varios temas como en el ejemplo anterior. El servicio se instala automáticamente (pero no se inicia)
si instala el paquete deb/rpm. Para configurarlo, simplemente edite `/etc/ntfy/client.yml` y ejecutar `sudo systemctl restart ntfy-client`.
!!! información
El `ntfy-client.service` se ejecuta como usuario `ntfy`, lo que significa que se aplican restricciones de permisos típicas de Linux. Vea a continuación
para saber cómo solucionarlo.
Si el servicio se ejecuta en el equipo de escritorio personal, es posible que desee invalidar el usuario/grupo de servicio (`User=` y `Group=`), y
ajustar el `DISPLAY` y `DBUS_SESSION_BUS_ADDRESS` variables de entorno. Esto le permitirá ejecutar comandos en su sesión X
como usuario principal de la máquina.
Puede invalidar manualmente estas entradas de servicio systemd con `sudo systemctl edit ntfy-client`, y agregue esto
(suponiendo que su usuario es `phil`). No te olvides de correr `sudo systemctl daemon-reload` y `sudo systemctl restart ntfy-client`
después de editar el archivo de servicio:
\=== "/etc/systemd/system/ntfy-client.service.d/override.conf"
` [Service]
User=phil
Group=phil
Environment="DISPLAY=:0" "DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/1000/bus"
`
O bien, puede ejecutar el siguiente script que crea esta configuración de anulación por usted:
sudo sh -c 'cat > /etc/systemd/system/ntfy-client.service.d/override.conf' <<EOF
[Service]
User=$USER
Group=$USER
Environment="DISPLAY=:0" "DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/$(id -u)/bus"
EOF
sudo systemctl daemon-reload
sudo systemctl restart ntfy-client
### Autenticación
Dependiendo de si el servidor está configurado para admitir [control de acceso](../config.md#access-control), algunos temas
puede estar protegido contra lectura/escritura para que solo los usuarios con las credenciales correctas puedan suscribirse o publicar en ellos.
Para publicar/suscribirse a temas protegidos, puede utilizar [Autenticación básica](https://en.wikipedia.org/wiki/Basic_access_authentication)
con un nombre de usuario/contraseña válido. Para su servidor autohospedado, **Asegúrese de usar HTTPS para evitar escuchas** y exponer
su contraseña.
Puede agregar su nombre de usuario y contraseña al archivo de configuración:
\=== "~/.config/ntfy/client.yml"
`yaml - topic: secret
command: 'notify-send "$m"'
user: phill
password: mypass
`
O con el `ntfy subscibe` mandar:
ntfy subscribe \
-u phil:mypass \
ntfy.example.com/mysecrets

240
docs/subscribe/phone-es.md Normal file
View file

@ -0,0 +1,240 @@
# Suscríbete desde tu teléfono
Puedes usar el ntfy [Aplicación android](https://play.google.com/store/apps/details?id=io.heckel.ntfy) o [Aplicación iOS](https://apps.apple.com/us/app/ntfy/id1625396347)
para recibir notificaciones directamente en tu teléfono. Al igual que el servidor, esta aplicación también es de código abierto y el código está disponible.
en GitHub ([Androide](https://github.com/binwiederhier/ntfy-android), [Ios](https://github.com/binwiederhier/ntfy-ios)). Siéntase libre de
contribuir, o [construye el tuyo propio](../develop.md).
<a href="https://play.google.com/store/apps/details?id=io.heckel.ntfy"><img src="../../static/img/badge-googleplay.png"></a> <a href="https://f-droid.org/en/packages/io.heckel.ntfy/"><img src="../../static/img/badge-fdroid.png"></a> <a href="https://apps.apple.com/us/app/ntfy/id1625396347"><img src="../../static/img/badge-appstore.png"></a>
Puede obtener la aplicación de Android desde ambos [Google Play](https://play.google.com/store/apps/details?id=io.heckel.ntfy) y
De [F-Droide](https://f-droid.org/en/packages/io.heckel.ntfy/). Ambos son en gran medida idénticos, con la única excepción de que
el sabor F-Droid no utiliza Firebase. La aplicación iOS se puede descargar desde el [Tienda de aplicaciones](https://apps.apple.com/us/app/ntfy/id1625396347).
## Visión general
Una imagen vale más que mil palabras. Aquí hay algunas capturas de pantalla que muestran cómo se ve la aplicación. Todo es bonito
Sencillo. Puede agregar temas y tan pronto como los agregue, puede [publicar mensajes](../publish.md) a ellos.
<div id="android-screenshots" class="screenshots">
<a href="../../static/img/android-screenshot-main.png"><img src="../../static/img/android-screenshot-main.png"/></a>
<a href="../../static/img/android-screenshot-detail.png"><img src="../../static/img/android-screenshot-detail.png"/></a>
<a href="../../static/img/android-screenshot-pause.png"><img src="../../static/img/android-screenshot-pause.png"/></a>
<a href="../../static/img/android-screenshot-add.png"><img src="../../static/img/android-screenshot-add.png"/></a>
<a href="../../static/img/android-screenshot-add-instant.png"><img src="../../static/img/android-screenshot-add-instant.png"/></a>
<a href="../../static/img/android-screenshot-add-other.png"><img src="../../static/img/android-screenshot-add-other.png"/></a>
</div>
Si esas capturas de pantalla aún no son suficientes, aquí hay un video:
<figure>
<video controls muted autoplay loop width="650" src="../../static/img/android-video-overview.mp4"></video>
<figcaption>Sending push notifications to your Android phone</figcaption>
</figure>
## Prioridad del mensaje
*Soportado en:* :material-android: :material-manzana:
Cuando [publicar mensajes](../publish.md#message-priority) a un tema, puedes **definir una prioridad**. Esta prioridad define
con qué urgencia Android le notificará sobre la notificación y si hacen un sonido y / o vibran.
De forma predeterminada, los mensajes con prioridad predeterminada o superior (> = 3) vibrarán y emitirán un sonido. Mensajes con alto o urgente
la prioridad (> = 4) también se mostrará como pop-over, así:
<figure markdown>
![priority notification](../static/img/priority-notification.png){ width=500 }
<figcaption>High and urgent notifications show as pop-over</figcaption>
</figure>
Puede cambiar esta configuración en Android presionando prolongadamente la aplicación y tocando "Notificaciones" o desde "Configuración"
en "Configuración del canal". Hay un canal de notificación para cada prioridad:
<figure markdown>
![notification settings](../static/img/android-screenshot-notification-settings.png){ width=500 }
<figcaption>Per-priority channels</figcaption>
</figure>
Por canal de notificación, puede configurar un **sonido específico del canal**, si se debe **Anular el DND de No molestar (DND)**
configuración y otras configuraciones como popover o punto de notificación:
<figure markdown>
![channel details](../static/img/android-screenshot-notification-details.jpg){ width=500 }
<figcaption>Per-priority sound/vibration settings</figcaption>
</figure>
## Entrega instantánea
*Soportado en:* :material-androide:
La entrega instantánea le permite recibir mensajes en su teléfono al instante, **incluso cuando el teléfono está en modo dormitado**, es decir,
cuando la pantalla se apaga y la dejas en el escritorio por un tiempo. Esto se logra con un servicio en primer plano, que
verás como una notificación permanente que se ve así:
<figure markdown>
![foreground service](../static/img/foreground-service.png){ width=500 }
<figcaption>Instant delivery foreground notification</figcaption>
</figure>
Android no le permite descartar esta notificación, a menos que desactive el canal de notificación en la configuración.
Para hacerlo, mantenga presionada la notificación en primer plano (captura de pantalla anterior) y navegue hasta la configuración. A continuación, cambie el botón
"Servicio de suscripción" desactivado:
<figure markdown>
![foreground service](../static/img/notification-settings.png){ width=500 }
<figcaption>Turning off the persistent instant delivery notification</figcaption>
</figure>
**Limitaciones sin entrega instantánea**: Sin entrega instantánea, **Los mensajes pueden llegar con un retraso significativo**
(a veces muchos minutos, o incluso horas después). Si alguna vez has cogido el teléfono y
de repente tuve 10 mensajes que se enviaron mucho antes de que supieras de lo que estoy hablando.
La razón de esto es [Mensajería en la nube de Firebase (FCM)](https://firebase.google.com/docs/cloud-messaging). FCM es el
*solamente* Google aprobó la forma de enviar mensajes push a dispositivos Android, y es lo que casi todas las aplicaciones usan para entregar push
notificaciones. Firebase es en general bastante malo para entregar mensajes a tiempo, pero en Android, la mayoría de las aplicaciones están atascadas con él.
La aplicación ntfy para Android usa Firebase solo para el host principal `ntfy.sh`, y solo en el sabor Google Play de la aplicación.
No usará Firebase para ningún servidor autohospedado, y no en absoluto en el sabor F-Droid.
## Compartir en el tema
*Soportado en:* :material-androide:
Puede compartir archivos en un tema utilizando la función "Compartir" de Android. Esto funciona en casi cualquier aplicación que admita compartir archivos
o texto, y es útil para enviarse enlaces, archivos u otras cosas. La función recuerda algunos de los últimos temas
compartiste contenido y los enumeras en la parte inferior.
La característica es bastante autoexplicativa, y una imagen dice más de mil palabras. Así que aquí hay dos imágenes:
<div id="share-to-topic-screenshots" class="screenshots">
<a href="../../static/img/android-screenshot-share-1.jpg"><img src="../../static/img/android-screenshot-share-1.jpg"/></a>
<a href="../../static/img/android-screenshot-share-2.jpg"><img src="../../static/img/android-screenshot-share-2.jpg"/></a>
</div>
## ntfy:// enlaces
*Soportado en:* :material-androide:
La aplicación ntfy para Android admite enlaces profundos directamente a los temas. Esto es útil cuando se integra con [aplicaciones de automatización](#automation-apps)
como [Macrodroid](https://play.google.com/store/apps/details?id=com.arlosoft.macrodroid) o [Tasker](https://play.google.com/store/apps/details?id=net.dinglisch.android.taskerm),
o simplemente para vincular directamente a un tema desde un sitio web móvil.
!!! información
La vinculación profunda de Android de enlaces http / https es muy frágil y limitada, por lo que algo como `https://<host>/<topic>/subscribe` es
**no es posible**, y en su lugar `ntfy://` hay que utilizar enlaces. Más detalles en [número #20](https://github.com/binwiederhier/ntfy/issues/20).
**Formatos de enlace compatibles:**
| Formato de enlace | Ejemplo | Descripción |
|-------------------------------------------------------------------------------|-------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| <span style="white-space: nowrap">`ntfy://<host>/<topic>`</span> | `ntfy://ntfy.sh/mytopic` | Abre directamente la vista de detalles de la aplicación de Android para el tema y el servidor dados. Se suscribe al tema si aún no está suscrito. Esto es equivalente a la vista web `https://ntfy.sh/mytopic` (¡HTTPS!) |
| <span style="white-space: nowrap">`ntfy://<host>/<topic>?secure=false`</span> | `ntfy://example.com/mytopic?secure=false` | Igual que el anterior, excepto que esto usará HTTP en lugar de HTTPS como URL del tema. Esto es equivalente a la vista web `http://example.com/mytopic` (¡HTTP!) |
## Integraciones
### UnifiedPush
*Soportado en:* :material-androide:
[UnifiedPush](https://unifiedpush.org) es un estándar para recibir notificaciones push sin usar la propiedad de Google
[Mensajería en la nube de Firebase (FCM)](https://firebase.google.com/docs/cloud-messaging) servicio. Pone notificaciones push
en el control del usuario. ntfy puede actuar como un **Distribuidor de UnifiedPush**, reenviar mensajes a aplicaciones que lo admitan.
Para utilizar ntfy como distribuidor, simplemente selecciónelo en uno de los [aplicaciones compatibles](https://unifiedpush.org/users/apps/).
Eso es todo. Es una instalación 😀 de un solo paso. Si lo desea, puede seleccionar el suyo propio [servidor ntfy autohospedado](../install.md)
para manejar mensajes. Aquí hay un ejemplo con [FluffyChat](https://fluffychat.im/):
<div id="unifiedpush-screenshots" class="screenshots">
<a href="../../static/img/android-screenshot-unifiedpush-fluffychat.jpg"><img src="../../static/img/android-screenshot-unifiedpush-fluffychat.jpg"/></a>
<a href="../../static/img/android-screenshot-unifiedpush-subscription.jpg"><img src="../../static/img/android-screenshot-unifiedpush-subscription.jpg"/></a>
<a href="../../static/img/android-screenshot-unifiedpush-settings.jpg"><img src="../../static/img/android-screenshot-unifiedpush-settings.jpg"/></a>
</div>
### Aplicaciones de automatización
*Soportado en:* :material-androide:
La aplicación ntfy para Android se integra muy bien con aplicaciones de automatización como [Macrodroid](https://play.google.com/store/apps/details?id=com.arlosoft.macrodroid)
o [Tasker](https://play.google.com/store/apps/details?id=net.dinglisch.android.taskerm). Usando las intenciones de Android, puedes
**reaccionar a los mensajes entrantes**, así como **enviar mensajes**.
#### Reaccionar a los mensajes entrantes
Para reaccionar a las notificaciones entrantes, debe registrarse en intents con el `io.heckel.ntfy.MESSAGE_RECEIVED` acción (véase
[código para más detalles](https://github.com/binwiederhier/ntfy-android/blob/main/app/src/main/java/io/heckel/ntfy/msg/BroadcastService.kt)).
Aquí hay un ejemplo usando [Macrodroid](https://play.google.com/store/apps/details?id=com.arlosoft.macrodroid)
y [Tasker](https://play.google.com/store/apps/details?id=net.dinglisch.android.taskerm), pero cualquier aplicación que pueda atrapar
se admiten transmisiones:
<div id="integration-screenshots-receive" class="screenshots">
<a href="../../static/img/android-screenshot-macrodroid-overview.png"><img src="../../static/img/android-screenshot-macrodroid-overview.png"/></a>
<a href="../../static/img/android-screenshot-macrodroid-trigger.png"><img src="../../static/img/android-screenshot-macrodroid-trigger.png"/></a>
<a href="../../static/img/android-screenshot-macrodroid-action.png"><img src="../../static/img/android-screenshot-macrodroid-action.png"/></a>
<a href="../../static/img/android-screenshot-tasker-profiles.png"><img src="../../static/img/android-screenshot-tasker-profiles.png"/></a>
<a href="../../static/img/android-screenshot-tasker-event-edit.png"><img src="../../static/img/android-screenshot-tasker-event-edit.png"/></a>
<a href="../../static/img/android-screenshot-tasker-task-edit.png"><img src="../../static/img/android-screenshot-tasker-task-edit.png"/></a>
<a href="../../static/img/android-screenshot-tasker-action-edit.png"><img src="../../static/img/android-screenshot-tasker-action-edit.png"/></a>
</div>
Para MacroDroid, asegúrese de escribir el nombre del paquete `io.heckel.ntfy`, de lo contrario, las intenciones pueden tragarse en silencio.
Si usas temas para impulsar la automatización, es probable que desees silenciar el tema en la aplicación ntfy. Esto evitará
ventanas emergentes de notificación:
<figure markdown>
![muted subscription](../static/img/android-screenshot-muted.png){ width=500 }
<figcaption>Muting notifications to prevent popups</figcaption>
</figure>
Aquí hay una lista de extras a los que puede acceder. Lo más probable es que desee filtrar por `topic` y reaccionar en `message`:
| Nombre adicional | Tipo | Ejemplo | Descripción |
|----------------------|------------------------------|------------------------------------------|------------------------------------------------------------------------------------|
| `id` | *Cuerda* | `bP8dMjO8ig` | Identificador de mensaje elegido al azar (probablemente no muy útil para la automatización de tareas) |
| `base_url` | *Cuerda* | `https://ntfy.sh` | URL raíz del servidor ntfy este mensaje proviene de |
| `topic` ❤️ | *Cuerda* | `mytopic` | Nombre del tema; **Es probable que desee filtrar por un tema específico** |
| `muted` | *Booleano* | `true` | Indica si la suscripción se silenció en la aplicación |
| `muted_str` | *Cadena (`true` o `false`)* | `true` | Igual que `muted`, pero como cadena `true` o `false` |
| `time` | *Int* | `1635528741` | Hora de la fecha del mensaje, como | de la marca de tiempo de Unix
| `title` | *Cuerda* | `Some title` | Mensaje [título](../publish.md#message-title); puede estar vacío si no está configurado |
| `message` ❤️ | *Cuerda* | `Some message` | Cuerpo del mensaje; **Esto es probablemente lo que te interesa** |
| `message_bytes` | *ByteArray* | `(binary data)` | Cuerpo del mensaje como | de datos binarios
| `encoding`️ | *Cuerda* | - | Codificación de mensajes (vacía o "base64") |
| `tags` | *Cuerda* | `tag1,tag2,..` | Lista separada por comas de [Etiquetas](../publish.md#tags-emojis) |
| `tags_map` | *Cuerda* | `0=tag1,1=tag2,..` | Mapa de etiquetas para facilitar el mapeo primero, segundo, ... | de etiquetas
| `priority` | *Int (entre 1-5)* | `4` | Mensaje [prioridad](../publish.md#message-priority) con 1=min, 3=default y 5=max |
| `click` | *Cuerda* | `https://google.com` | [Haga clic en la acción](../publish.md#click-action) URL, o vacía si no está establecida |
| `attachment_name` | *Cuerda* | `attachment.jpg` | Nombre de archivo del archivo adjunto; puede estar vacío si no está configurado |
| `attachment_type` | *Cuerda* | `image/jpeg` | Tipo mimo del accesorio; puede estar vacío si no está configurado |
| `attachment_size` | *Largo* | `9923111` | Tamaño en bytes del archivo adjunto; puede ser cero si no se establece |
| `attachment_expires` | *Largo* | `1655514244` | Fecha de caducidad como marca de tiempo Unix de la URL adjunta; puede ser cero si no se establece |
| `attachment_url` | *Cuerda* | `https://ntfy.sh/file/afUbjadfl7ErP.jpg` | URL del archivo adjunto; puede estar vacío si no está configurado |
#### Enviar mensajes mediante intenciones
Para enviar mensajes desde otras aplicaciones (como [Macrodroid](https://play.google.com/store/apps/details?id=com.arlosoft.macrodroid)
y [Tasker](https://play.google.com/store/apps/details?id=net.dinglisch.android.taskerm)), puede
transmitir una intención con el `io.heckel.ntfy.SEND_MESSAGE` acción. La aplicación ntfy para Android reenviará la intención como un HTTP
SOLICITUD POST a [publicar un mensaje](../publish.md). Esto es principalmente útil para aplicaciones que no admiten HTTP POST/PUT
(como MacroDroid). En Tasker, simplemente puede usar la acción "Solicitud HTTP", que es un poco más fácil y también funciona si
ntfy no está instalado.
Así es como se ve:
<div id="integration-screenshots-send" class="screenshots">
<a href="../../static/img/android-screenshot-macrodroid-send-macro.png"><img src="../../static/img/android-screenshot-macrodroid-send-macro.png"/></a>
<a href="../../static/img/android-screenshot-macrodroid-send-action.png"><img src="../../static/img/android-screenshot-macrodroid-send-action.png"/></a>
<a href="../../static/img/android-screenshot-tasker-profile-send.png"><img src="../../static/img/android-screenshot-tasker-profile-send.png"/></a>
<a href="../../static/img/android-screenshot-tasker-task-edit-post.png"><img src="../../static/img/android-screenshot-tasker-task-edit-post.png"/></a>
<a href="../../static/img/android-screenshot-tasker-action-http-post.png"><img src="../../static/img/android-screenshot-tasker-action-http-post.png"/></a>
</div>
Los siguientes extras de intención son compatibles cuando para la intención con el `io.heckel.ntfy.SEND_MESSAGE` acción:
| Nombre adicional | | requerido Tipo | Ejemplo | Descripción |
|--------------|----------|-------------------------------|-------------------|------------------------------------------------------------------------------------|
| `base_url` | - | *Cuerda* | `https://ntfy.sh` | La dirección URL raíz del servidor ntfy del que procede este mensaje, de forma predeterminada es `https://ntfy.sh` |
| `topic` ❤️ | ✔ | *Cuerda* | `mytopic` | Nombre del tema; **Debe establecer esto** |
| `title` | - | *Cuerda* | `Some title` | Mensaje [título](../publish.md#message-title); puede estar vacío si no está configurado |
| `message` ❤️ | ✔ | *Cuerda* | `Some message` | Cuerpo del mensaje; **Debe establecer esto** |
| `tags` | - | *Cuerda* | `tag1,tag2,..` | Lista separada por comas de [Etiquetas](../publish.md#tags-emojis) |
| `priority` | - | *String o Int (entre 1-5)* | `4` | Mensaje [prioridad](../publish.md#message-priority) con 1=min, 3=default y 5=max |

21
docs/subscribe/web-es.md Normal file
View file

@ -0,0 +1,21 @@
# Suscribirse desde la interfaz de usuario web
También puede usar la interfaz de usuario web para suscribirse a temas. Si lo hace, y mantiene el sitio web abierto, **notificaciones
aparece como notificaciones de escritorio**. Simplemente escriba el nombre del tema y haga clic en el botón *Subscribir* botón. El navegador
mantenga una conexión abierta y escuche las notificaciones entrantes.
Para obtener información sobre cómo enviar mensajes, consulte el [página de publicación](../publish.md).
<div id="web-screenshots" class="screenshots">
<a href="../../static/img/web-detail.png"><img src="../../static/img/web-detail.png"/></a>
<a href="../../static/img/web-notification.png"><img src="../../static/img/web-notification.png"/></a>
<a href="../../static/img/web-subscribe.png"><img src="../../static/img/web-subscribe.png"/></a>
</div>
Para seguir recibiendo notificaciones de escritorio de ntfy, debe mantener el sitio web abierto. Lo que hago, y lo que recomiendo encarecidamente,
es anclar la pestaña para que siempre esté abierta, pero algo fuera del camino:
<figure markdown>
![pinned](../static/img/web-pin.png){ width=500 }
<figcaption>Pin web app to move it out of the way</figcaption>
</figure>