# Infinity — Despliegue con Docker

Esta guía explica cómo llevar el proyecto a cualquier PC con Docker, usando Gitea como origen del código.

## Requisitos en el PC destino

- Docker instalado y corriendo.
- Docker Compose instalado (normalmente viene con Docker Desktop; en Linux puede ser el plugin `docker compose`).
- Git (para clonar desde Gitea).

## Estructura del proyecto

```
.
├── backend/          # Código del servidor Node.js/Express
│   ├── Dockerfile
│   ├── docker-entrypoint.sh
│   ├── package.json
│   └── server.js
├── frontend/         # Archivos estáticos del catálogo y panel admin
├── data/             # JSONs persistentes (categorías, productos, usuarios...)
├── Imagenes/         # Fotos de productos
├── pedidos/          # PDFs de pedidos
├── videos/           # Videos del catálogo
├── agotados/         # Imágenes de productos agotados
├── docker-compose.yml
└── .dockerignore
```

## Pasos para ponerlo a correr en otro PC

### 1. Clonar el repositorio desde Gitea

```bash
git clone https://TU_GITEA/TU_USUARIO/infinity.git
cd infinity
```

### 2. Levantar el contenedor

```bash
docker compose up --build -d
```

- Construye la imagen con el backend y el frontend empaquetados.
- Expone la aplicación en: http://localhost:6060
- Persiste `data/`, `Imagenes/`, `pedidos/` y `videos/` en el host.

### 3. Abrir en el navegador

- Catálogo público: http://localhost:6060
- Panel administrativo: http://localhost:6060/administrativo/

### Usuario por defecto (solo si no existe `data/contraseñas.json`)

| Campo      | Valor |
|------------|-------|
| Usuario    | admin |
| Contraseña | admin |

> Cambia esta contraseña desde el panel administrativo lo antes posible.

## Flujo de trabajo: editar en este PC y actualizar el otro

1. Haces los cambios en el código/frontend.
2. Subes a Gitea:
   ```bash
   git add .
   git commit -m "descripción del cambio"
   git push origin main
   ```
3. En el otro PC:
   ```bash
   cd infinity
   git pull
   docker compose down
   docker compose up --build -d
   ```

Con eso se actualiza tanto el backend como el frontend.

## Datos importantes: qué se guarda y qué no

Lo que **sí** se conserva al reconstruir el contenedor (está en volúmenes):

- `data/` → JSONs (productos, categorías, usuarios, sesiones...)
- `Imagenes/` → fotos subidas
- `pedidos/` → PDFs generados
- `videos/` → videos subidos

Lo que **no** se conserva (va dentro de la imagen):

- El código del frontend y backend. Si lo actualizas, hay que hacer `docker compose up --build -d`.

## Comandos útiles

| Acción | Comando |
|--------|---------|
| Ver logs | `docker compose logs -f web` |
| Reiniciar | `docker compose restart web` |
| Apagar | `docker compose down` |
| Borrar TODO (incluidos datos locales) | `docker compose down -v` ⚠️ |
| Ver estado | `docker compose ps` |

## Solución de problemas

### "Cannot GET /" o pantalla en blanco

1. Verifica que el contenedor esté corriendo:
   ```bash
   docker compose ps
   ```
2. Mira los logs:
   ```bash
   docker compose logs -f web
   ```
3. Asegúrate de haber usado `--build` después de `git pull`.

### El admin no entra

- Si la carpeta `data/` estaba vacía, se crea automáticamente el usuario `admin`/`admin`.
- Si ya existe `data/contraseñas.json`, ese archivo tiene prioridad.

### Las imágenes o pedidos no aparecen

- Confirma que las carpetas `Imagenes/`, `pedidos/` y `videos/` están en la misma ubicación que `docker-compose.yml`.
- En Windows con Docker Desktop, activa **Settings → Resources → File sharing** para la unidad donde esté el proyecto.

## Notas de seguridad

- Cambia `SESSION_SECRET` en `docker-compose.yml` por algo aleatorio y largo si vas a exponer el sitio a internet.
- El proyecto está pensado para red local / catálogo interno. No expongas el puerto 6060 a internet sin un reverse proxy (nginx/traefik) y HTTPS.

## ¿Por qué se empaqueta el frontend dentro de la imagen?

Así, cuando subes cambios a Gitea y haces `git pull` + `--build` en el otro PC, el frontend se actualiza automáticamente. Si se montara `frontend/` como volumen, el contenedor usaría siempre los archivos antiguos que ya estuvieran en el disco.