# Desarrollo

¡Hurra 🥳 🎉, estás interesado en escribir código para ntfy! **Eso es increíble.** 😎

Hice todo lo posible para escribir instrucciones detalladas, pero si en algún momento te encuentras con problemas, no lo hagas.
dudar en **contáctame en [Discordia](https://discord.gg/cT7ECsZj9w) o [Matriz](https://matrix.to/#/#ntfy:matrix.org)**.

## Servidor ntfy

El código fuente del servidor ntfy está disponible [en GitHub](https://github.com/binwiederhier/ntfy). La base de código para el
el servidor consta de tres componentes:

*   **El servidor/cliente principal** está escrito en [Ir](https://go.dev/) (así que necesitarás Go). Su punto de entrada principal está en
    [main.go](https://github.com/binwiederhier/ntfy/blob/main/main.go), y la carne que probablemente te interese es
    en [servidor.go](https://github.com/binwiederhier/ntfy/blob/main/server/server.go). En particular, el servidor utiliza un
    [SQLite](https://sqlite.org) biblioteca llamada [go-sqlite3](https://github.com/mattn/go-sqlite3), que requiere
    [Cgo](https://go.dev/blog/cgo) y `CGO_ENABLED=1` para ser establecido. De lo contrario, las cosas no funcionarán (ver más abajo).
*   **La documentación** es generado por [MkDocs](https://www.mkdocs.org/) y [Material para MkDocs](https://squidfunk.github.io/mkdocs-material/),
    que está escrito en [Pitón](https://www.python.org/). Necesitarás Python y MkDocs (a través de `pip`) sólo si desea
    compila los documentos.
*   **La aplicación web** está escrito en [Reaccionar](https://reactjs.org/)Usando [MUI](https://mui.com/). Utiliza [Crear la aplicación React](https://create-react-app.dev/)
    para construir la compilación de producción. Si desea modificar la aplicación web, necesita [nodejs](https://nodejs.org/en/) (para `npm`)
    e instalar todas las 100.000 dependencias (*suspirar*).

Todos estos componentes se construyen y luego **horneado en un binario**.

### Navegación por el código

Código:

*   [main.go](https://github.com/binwiederhier/ntfy/blob/main/main.go) - Punto de entrada principal en la CLI, tanto para el servidor como para el cliente
*   [cmd/](https://github.com/binwiederhier/ntfy/tree/main/cmd) - Comandos de la CLI, como `serve` o `publish`
*   [servidor/](https://github.com/binwiederhier/ntfy/tree/main/server) - La carne de la lógica del servidor
*   [documentos/](https://github.com/binwiederhier/ntfy/tree/main/docs) - El [MkDocs](https://www.mkdocs.org/) documentación, consulte también `mkdocs.yml`
*   [web/](https://github.com/binwiederhier/ntfy/tree/main/web) - El [Reaccionar](https://reactjs.org/) aplicación, ver también `web/package.json`

Construcción relacionada:

*   [Makefile](https://github.com/binwiederhier/ntfy/blob/main/Makefile) - Punto de entrada principal para todo lo relacionado con la construcción
*   [.goreleaser.yml](https://github.com/binwiederhier/ntfy/blob/main/.goreleaser.yml) - Describe todos los resultados de compilación (para [GoReleaser](https://goreleaser.com/))
*   [go.mod](https://github.com/binwiederhier/ntfy/blob/main/go.mod) - Archivo de dependencia de módulos Go
*   [mkdocs.yml](https://github.com/binwiederhier/ntfy/blob/main/mkdocs.yml) - Archivo de configuración para los documentos (para [MkDocs](https://www.mkdocs.org/))
*   [web/paquete.json](https://github.com/binwiederhier/ntfy/blob/main/web/package.json) - Compilación y archivo de dependencia para la aplicación web (para npm)

El `web/` y `docs/` son los orígenes de la aplicación web y la documentación. Durante el proceso de construcción,
El resultado generado se copia en `server/site` (aplicación web y página de destino) y `server/docs` (documentación).

### Requisitos de compilación

*   [Ir](https://go.dev/) (requerido para el servidor principal)
*   [Gcc](https://gcc.gnu.org/) (servidor principal requerido, para enlaces basados en SQLite cgo)
*   [Hacer](https://www.gnu.org/software/make/) (requerido por conveniencia)
*   [libsqlite3/libsqlite3-dev](https://www.sqlite.org/) (requerido para el servidor principal, para enlaces basados en SQLite cgo)
*   [GoReleaser](https://goreleaser.com/) (requerido para una compilación adecuada del servidor principal)
*   [Pitón](https://www.python.org/) (para `pip`, sólo para compilar los documentos)
*   [nodejs](https://nodejs.org/en/) (para `npm`, solo para compilar la aplicación web)

### Instalar dependencias

Estos pasos **asumir Ubuntu**. Los pasos pueden variar en diferentes distribuciones de Linux.

Primero, instale [Ir](https://go.dev/) (ver [instrucciones oficiales](https://go.dev/doc/install)):

```shell
wget https://go.dev/dl/go1.18.linux-amd64.tar.gz
rm -rf /usr/local/go && tar -C /usr/local -xzf go1.18.linux-amd64.tar.gz
export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin
go version   # verifies that it worked
```

Instalar [GoReleaser](https://goreleaser.com/) (ver [instrucciones oficiales](https://goreleaser.com/install/)):

```shell
go install github.com/goreleaser/goreleaser@latest
goreleaser -v   # verifies that it worked
```

Instalar [nodejs](https://nodejs.org/en/) (ver [instrucciones oficiales](https://nodejs.org/en/download/package-manager/)):

```shell
curl -fsSL https://deb.nodesource.com/setup_17.x | sudo -E bash -
sudo apt-get install -y nodejs
npm -v   # verifies that it worked
```

A continuación, instale algunas otras cosas necesarias:

```shell
sudo apt install \
    build-essential \
    libsqlite3-dev \
    gcc-arm-linux-gnueabi \
    gcc-aarch64-linux-gnu \
    python3-pip \
    upx \
    git
```

### Comprobar código

Ahora echa un vistazo a través de git desde el [Repositorio de GitHub](https://github.com/binwiederhier/ntfy):

\=== "vía HTTPS"
` shell
    git clone https://github.com/binwiederhier/ntfy.git
    cd ntfy
    `

\=== "vía SSH"
` shell
    git clone git@github.com:binwiederhier/ntfy.git 
    cd ntfy
    `

### Construye todas las cosas

Ahora finalmente puedes construir todo. Hay toneladas de `make` objetivos, así que tal vez solo revise lo que hay primero
escribiendo `make`:

```shell
$ make 
Typical commands (more see below):
  make build                   - Build web app, documentation and server/client (sloowwww)
  make cli-linux-amd64         - Build server/client binary (amd64, no web app or docs)
  make install-linux-amd64     - Install ntfy binary to /usr/bin/ntfy (amd64)
  make web                     - Build the web app
  make docs                    - Build the documentation
  make check                   - Run all tests, vetting/formatting checks and linters
...
```

Si quieres construir el **Ntfy binario, incluida la aplicación web y los documentos para todas las arquitecturas compatibles** (amd64, armv7 y arm64),
simplemente puede ejecutar `make build`:

```shell
$ make build
...
# This builds web app, docs, and the ntfy binary (for amd64, armv7 and arm64). 
# This will be SLOW (5+ minutes on my laptop on the first run). Maybe look at the other make targets?
```

Verás todas las salidas en el `dist/` carpeta después:

```bash
$ find dist 
dist
dist/metadata.json
dist/ntfy_arm64_linux_arm64
dist/ntfy_arm64_linux_arm64/ntfy
dist/ntfy_armv7_linux_arm_7
dist/ntfy_armv7_linux_arm_7/ntfy
dist/ntfy_amd64_linux_amd64
dist/ntfy_amd64_linux_amd64/ntfy
dist/config.yaml
dist/artifacts.json
```

Si también desea construir el **Paquetes Debian/RPM e imágenes de Docker para todas las arquitecturas soportadas**Puedes
utilice el botón `make release-snapshot` blanco:

```shell
$ make release-snapshot
...
# This will be REALLY SLOW (sometimes 5+ minutes on my laptop)
```

Durante el desarrollo, es posible que desee ser más exigente y construir solo ciertas cosas. Aquí hay algunos ejemplos.

### Construir el binario ntfy

Para construir sólo el `ntfy` binario **sin la aplicación web o la documentación**, utilice el botón `make cli-...` Objetivos:

```shell
$ make
Build server & client (using GoReleaser, not release version):
  make cli                        - Build server & client (all architectures)
  make cli-linux-amd64            - Build server & client (Linux, amd64 only)
  make cli-linux-armv6            - Build server & client (Linux, armv6 only)
  make cli-linux-armv7            - Build server & client (Linux, armv7 only)
  make cli-linux-arm64            - Build server & client (Linux, arm64 only)
  make cli-windows-amd64          - Build client (Windows, amd64 only)
  make cli-darwin-all             - Build client (macOS, arm64+amd64 universal binary)
```

Entonces, si está en una máquina basada en amd64 / x86\_64, es posible que solo desee ejecutar `make cli-linux-amd64` durante las pruebas. En un moderno
sistema, esto no debería tomar más de 5-10 segundos. A menudo lo combino con `install-linux-amd64` para que pueda ejecutar el binario
Ahora mismo:

```shell
$ make cli-linux-amd64 install-linux-amd64
$ ntfy serve
```

**Durante el desarrollo de la aplicación principal, también puede usar `go run main.go`**, siempre y cuando corras
`make cli-deps-static-sites`al menos una vez y `CGO_ENABLED=1`:

```shell
$ export CGO_ENABLED=1
$ make cli-deps-static-sites
$ go run main.go serve
2022/03/18 08:43:55 Listening on :2586[http]
...
```

Si no corres `cli-deps-static-sites`, es posible que vea un error *`pattern ...: no matching files found`*:

    $ go run main.go serve
    server/server.go:85:13: pattern docs: no matching files found

Esto se debe a que usamos `go:embed` para incrustar la documentación y la aplicación web, por lo que el código Go espera que los archivos sean
presente en `server/docs` y `server/site`. Si no lo son, verá el error anterior. El `cli-deps-static-sites`
target crea archivos ficticios que garantizan que podrá compilar.

Aunque no es oficialmente compatible (o lanzado), puede compilar y ejecutar el servidor **en macOS** También. Simplemente ejecute
`make cli-darwin-server` para crear un binario, o `go run main.go serve` (ver arriba) para ejecutarlo.

### Compilar la aplicación web

Los orígenes de la aplicación web viven en `web/`. Siempre y cuando tengas `npm` instalado (consulte más arriba), creación de la aplicación web
es realmente simple. Simplemente escriba `make web` y estás en el negocio:

```shell
$ make web
...
```

Esto creará la aplicación web mediante Crear aplicación React y luego **Copie la compilación de producción en el cuadro `server/site` carpeta**así que
que cuando `make cli` (o `make cli-linux-amd64`, ...), tendrás la web app incluida en el `ntfy` binario.

Si está desarrollando en la aplicación web, es mejor simplemente `cd web` y ejecutar `npm start` manualmente. Esto abrirá su navegador
en `http://127.0.0.1:3000` con la aplicación web, y a medida que edite los archivos de origen, se volverán a compilar y el explorador
se actualizará automáticamente:

```shell
$ cd web
$ npm start
```

### Crear los documentos

Las fuentes de los documentos viven en `docs/`. De manera similar a la aplicación web, simplemente puede ejecutar `make docs` para crear el
documentación. Siempre y cuando tengas `mkdocs` instalado (ver arriba), esto debería funcionar bien:

```shell
$ make docs
...
```

Si va a cambiar la documentación, debería estar ejecutando `mkdocs serve` directamente. Esto construirá la documentación,
Servir los archivos en `http://127.0.0.1:8000/`y vuelva a generar cada vez que guarde los archivos de origen:

    $ mkdocs serve
    INFO     -  Building documentation...
    INFO     -  Cleaning site directory
    INFO     -  Documentation built in 5.53 seconds
    INFO     -  [16:28:14] Serving on http://127.0.0.1:8000/

Luego puede navegar a http://127.0.0.1:8000/ y cada vez que cambie un archivo de marcado en su editor de texto, se actualizará automáticamente.

## Aplicación para Android

El código fuente de la aplicación ntfy para Android está disponible [en GitHub](https://github.com/binwiederhier/ntfy-android).
La aplicación de Android tiene dos sabores:

*   **Google Play:** El `play` sabor incluye [Base de fuego (FCM)](https://firebase.google.com/) y requiere una cuenta de Firebase
*   **F-Droide:** El `fdroid` Flavor no incluye dependencias de Firebase o Google

### Navegación por el código

*   [principal/](https://github.com/binwiederhier/ntfy-android/tree/main/app/src/main) - Código fuente principal de la aplicación Android
*   [jugar/](https://github.com/binwiederhier/ntfy-android/tree/main/app/src/play) - Código específico de Google Play / Firebase
*   [fdroid/](https://github.com/binwiederhier/ntfy-android/tree/main/app/src/fdroid) - Talones de F-Droid Firebase
*   [build.gradle](https://github.com/binwiederhier/ntfy-android/blob/main/app/build.gradle) - Archivo de compilación principal

### IDE/Medio ambiente

Deberías descargar [Estudio Android](https://developer.android.com/studio) (o [IntelliJ IDEA](https://www.jetbrains.com/idea/)
con los plugins de Android pertinentes). Todo lo demás será un dolor para ti. Hazte un favor. 😀

### Echa un vistazo al código

Primero echa un vistazo al repositorio:

\=== "vía HTTPS"
` shell
    git clone https://github.com/binwiederhier/ntfy-android.git
    cd ntfy-android
    `

\=== "vía SSH"
` shell
    git clone git@github.com:binwiederhier/ntfy-android.git
    cd ntfy-android
    `

A continuación, sigue los pasos para construir con o sin Firebase.

### Construir sabor F-Droid (sin FCM)

!!! información
Construyo la aplicación ntfy para Android usando IntelliJ IDEA (Android Studio), así que no sé si estos comandos de Gradle lo harán.
trabajar sin problemas. Por favor, dame tu opinión si funciona o no funciona para ti.

Sin Firebase, es posible que desees seguir cambiando el valor predeterminado `app_base_url` en [valores.xml](https://github.com/binwiederhier/ntfy-android/blob/main/app/src/main/res/values/values.xml)
si está autohospedando el servidor. Luego corre:

    # Remove Google dependencies (FCM)
    sed -i -e '/google-services/d' build.gradle
    sed -i -e '/google-services/d' app/build.gradle

    # To build an unsigned .apk (app/build/outputs/apk/fdroid/*.apk)
    ./gradlew assembleFdroidRelease

    # To build a bundle .aab (app/fdroid/release/*.aab)
    ./gradlew bundleFdroidRelease

### Sabor Build Play (FCM)

!!! información
Construyo la aplicación ntfy para Android usando IntelliJ IDEA (Android Studio), así que no sé si estos comandos de Gradle lo harán.
trabajar sin problemas. Por favor, dame tu opinión si funciona o no funciona para ti.

Para crear tu propia versión con Firebase, debes:

*   Crear una cuenta de Firebase/FCM
*   Coloque el archivo de su cuenta en `app/google-services.json`
*   Y cambio `app_base_url` en [valores.xml](https://github.com/binwiederhier/ntfy-android/blob/main/app/src/main/res/values/values.xml)
*   Luego corre:

<!---->

    # To build an unsigned .apk (app/build/outputs/apk/play/*.apk)
    ./gradlew assemblePlayRelease

    # To build a bundle .aab (app/play/release/*.aab)
    ./gradlew bundlePlayRelease

## Aplicación iOS

El código fuente de la aplicación ntfy iOS está disponible [en GitHub](https://github.com/binwiederhier/ntfy-ios).

!!! información
No he tenido tiempo de mover las instrucciones de compilación aquí. Por favor, echa un vistazo al repositorio en su lugar.