weather-station

Application cliente pour la station météo Bresser 7-en-1.

Stack : Angular 19 PWA (frontend) · ASP.NET Core 10 (backend) · SQL Server Express (BDD) · Docker (déploiement)

---

Fonctionnalités principales

Module	Description
Dashboard	Métriques en temps réel (polling 60 s) — température, humidité, pression, pluie, vent, UV, luminosité. Cartes configurables par glisser-déposer (CDK Drag & Drop), sparklines, boussole vent, alertes visuelles par seuil.
Exploration	Navigation par période (jour / semaine / mois / personnalisé), graphiques historiques Chart.js avec zoom, widgets adaptés par type de capteur.
Analyse avancée	Filtres multi-capteurs, graphiques de comparaison, statistiques (min/max/moyenne).
Alertes & Seuils	Définition de seuils par métrique, règles d'alerte, notifications push Web (VAPID).
Gestion des comptes	Authentification JWT, gestion des utilisateurs (admin).
PWA	Service Worker Angular — installable sur desktop et mobile, cache offline.

---

Développement local

Prérequis

• Docker Desktop (Windows)
• .NET SDK 10 (dotnet --version)
• Node.js 20 (node --version)
• SQL Server Express avec Mixed Mode Auth activé

Démarrer avec Docker

# 1. Copier et remplir les variables d'environnement
cp .env.example .env
# Editer .env : JWT__Secret, ConnectionStrings__DefaultConnection, ADMIN_DEFAULT_PASSWORD

# 2. Démarrer l'application
docker compose up --build

# Frontend  : http://localhost:8080
# Backend   : http://localhost:5000/api/v1/

Démarrer sans Docker

# Backend
cd src/back
dotnet run

# Frontend (autre terminal)
cd src/front
npm install
ng serve

Tests

cd src/back
dotnet test Tests/WeatherStation.Tests.csproj

---

Build & Publication (Docker ARM64 — Proxmox)

Prérequis (première fois)

Le script configure automatiquement le builder si absent, mais vous pouvez le préparer manuellement :

# Enregistrer QEMU pour la cross-compilation ARM64
docker run --rm --privileged tonistiigi/binfmt --install arm64

# Créer le builder multi-plateforme
docker buildx create --name weather-builder --driver docker-container --bootstrap --use

Publier les images

Les images sont poussées vers le registry OCI de Forgejo sous le compte fabrice :

• forgejo.homelab.com/fabrice/weather-station-backend:{tag}
• forgejo.homelab.com/fabrice/weather-station-frontend:{tag}
• forgejo.homelab.com/fabrice/weather-station-mcp:{tag}

# Publier la V1 (registry HTTP local — certificat auto-signé)
.\scripts\publish.ps1 -ImageTag 1.0.0 -Registry forgejo.homelab.com -Insecure

# Ou avec les variables d'environnement
$env:FORGEJO_REGISTRY = "forgejo.homelab.com"
$env:FORGEJO_OWNER    = "fabrice"
.\scripts\publish.ps1 -ImageTag 1.0.0 -Insecure

Remarque -Insecure : le daemon buildkit tourne dans un container Docker isolé et n'hérite pas des insecure-registries de Docker Desktop. Ce paramètre génère un fichier buildkitd.toml et recrée le builder pour accepter le registry HTTP/auto-signé.

Le script :

1. Login sur le registry Forgejo
2. Cross-compile backend + frontend + MCP en linux/arm64 via docker buildx
3. Pousse les images directement vers forgejo.homelab.com/fabrice/
4. Affiche les URLs des packages disponibles

Consulter les packages publiés : http://forgejo.homelab.com/fabrice/-/packages

---

Application mobile Android (APK)

L'application Angular peut être empaquetée en APK Android via Capacitor. Un widget écran d'accueil affiche la température et les conditions météo en temps réel.

Voir android/README.md pour le guide complet (prérequis, configuration Capacitor, signature release).

Générer l'APK (debug)

# APK debug
.\scripts\build-apk.ps1

# APK release (requiert une keystore configurée)
.\scripts\build-apk.ps1 -Release

# Sauter le build Angular si déjà compilé
.\scripts\build-apk.ps1 -SkipBuild

Le script :

1. Build Angular avec la configuration android (environment.android.ts)
2. Synchronise les assets dans le projet Capacitor
3. Génère les icônes launcher depuis docs/weather-station-icon.png
4. Intègre le widget écran d'accueil (copie + patch AndroidManifest.xml)
5. Compile l'APK via Gradle

Publier l'APK vers Forgejo

L'APK est publié dans les generic packages Forgejo sous fabrice/weather-station-apk :

# Prérequis : générer un token Forgejo avec permission package:write
# http://forgejo.homelab.com/user/settings/applications

# Compiler ET publier en une commande
.\scripts\publish-apk.ps1 -Version 1.0.0 -Build `
    -ForgejoUrl http://forgejo.homelab.com `
    -Token <votre-token>

# Publier un APK déjà compilé
.\scripts\publish-apk.ps1 -Version 1.0.0 `
    -ForgejoUrl http://forgejo.homelab.com `
    -Token <votre-token>

# APK release (signé)
.\scripts\publish-apk.ps1 -Version 1.0.0 -Build -Release `
    -ForgejoUrl http://forgejo.homelab.com `
    -Token <votre-token>

# Ou avec les variables d'environnement
$env:FORGEJO_URL   = "http://forgejo.homelab.com"
$env:FORGEJO_OWNER = "fabrice"
$env:FORGEJO_TOKEN = "<votre-token>"
.\scripts\publish-apk.ps1 -Version 1.0.0 -Build

Après publication, le package est visible sur : http://forgejo.homelab.com/fabrice/weather-station/packages

URL de téléchargement direct : http://forgejo.homelab.com/api/packages/fabrice/generic/weather-station-apk/1.0.0/weather-station-1.0.0-debug.apk

---

Déploiement Proxmox (LXC Docker)

# 1. Connexion au LXC
ssh user@proxmox-host

# 2. Login registry (première fois)
docker login forgejo.homelab.com

# 3. Créer .env.prod (première fois)
cp .env.prod.example .env.prod
nano .env.prod   # Remplir JWT__Secret, connection string prod, ADMIN_DEFAULT_PASSWORD
                 # Vérifier FORGEJO_REGISTRY=forgejo.homelab.com, FORGEJO_OWNER=fabrice, IMAGE_TAG=1.0.0

# 4. Déployer / Mettre à jour
# --env-file est obligatoire : les noms d'images (${FORGEJO_REGISTRY}, ${IMAGE_TAG}…)
# sont interpolés au parsing du fichier compose, PAS injectés via env_file des services.
docker compose -f docker-compose.prod.yml --env-file .env.prod pull
docker compose -f docker-compose.prod.yml --env-file .env.prod up -d

# 5. Vérifier
docker compose -f docker-compose.prod.yml --env-file .env.prod ps
docker compose -f docker-compose.prod.yml logs backend --tail=50

Accès

Couche	URL
Public (internet)	https://weather-station.xariox.fr — TLS terminé par le nginx externe
LAN direct	http://{ip-lxc}:80 — accès direct depuis le réseau Proxmox
Backend	Interne uniquement — proxifié par nginx Docker sur /api/ (non exposé)

La chaîne de proxy est : browser → nginx externe (TLS) → OPNsense → nginx Proxmox → Docker nginx → backend
Les headers X-Forwarded-For et X-Forwarded-Proto: https sont transmis à chaque étape.

Configuration nginx interne Proxmox (à faire une fois sur le serveur)

Ce nginx interne fait le lien entre OPNsense et le LXC Docker. Tout le trafic reste en HTTP — aucun certificat requis sur le homelab. Le TLS est uniquement terminé par le nginx public (côté internet).

Le seul point important : fixer X-Forwarded-Proto https en dur, car c'est un simple entête texte qui informe le backend que la requête originale du client était bien en HTTPS.

# /etc/nginx/sites-available/weather-station
server {
    listen 80;                              # HTTP uniquement — pas de certificat
    server_name weather-station.xariox.fr;

    location / {
        proxy_pass         http://{ip-lxc}:80;   # LXC Docker — HTTP également
        proxy_http_version 1.1;
        proxy_set_header   Host              $host;
        proxy_set_header   X-Real-IP         $remote_addr;
        proxy_set_header   X-Forwarded-For   $proxy_add_x_forwarded_for;
        # Hardcodé "https" car le nginx public a déjà terminé TLS avant cette étape.
        # C'est juste un entête texte — ne nécessite aucun certificat ici.
        proxy_set_header   X-Forwarded-Proto https;
    }
}

Remplacer {ip-lxc} par l'IP du LXC sur le réseau Proxmox.

---

Structure du projet

weather-station/
├── src/
│   ├── front/          # Angular 19 PWA
│   └── back/           # ASP.NET Core 10
├── android/            # Capacitor config + widget Android (sources staging)
├── docker/             # Dockerfiles + nginx.conf
├── docs/               # Documentation métier (seuils, icônes, algorithmes)
├── scripts/            # Scripts PowerShell
│   ├── publish.ps1         # Build & push images ARM64 backend/frontend/MCP vers Forgejo
│   ├── publish-apk.ps1     # Publication APK Android vers Forgejo generic packages
│   └── build-apk.ps1       # Génération APK Android via Capacitor
├── docker-compose.yml           # Dev local
├── docker-compose.prod.yml      # Production Proxmox
├── .env.example                 # Variables dev (modèle)
└── .env.prod.example            # Variables prod (modèle)