Adriano/TieMeasureFlow
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

docs: rewrite README with cleaner structure and less duplication

Browse Source 
Restructure README to be more concise: add feature overview section,
architecture diagram with security note, tabular stack listing,
streamlined quick start, and env vars reference table. Move VPS
deployment details to docs/DEPLOYMENT.md to avoid duplication.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Adriano
2026-02-25 12:00:47 +01:00
parent 429c94da94
commit 1578398f0f
1 changed files with 225 additions and 269 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README.md
+225 -269
View File
@@ -2,362 +2,285 @@
Sistema di gestione task per misurazioni con calibro manuale. Soluzione tablet-first, multi-ruolo, con statistiche SPC (Statistical Process Control) integrate. Sistema di gestione task per misurazioni con calibro manuale. Soluzione tablet-first, multi-ruolo, con statistiche SPC (Statistical Process Control) integrate.
---
## Panoramica
TieMeasureFlow guida l'operatore attraverso sequenze di misurazione definite dal Maker, registra i valori (da calibro USB HID o numpad touch), e valuta automaticamente la conformità rispetto alle tolleranze configurate. I dati raccolti alimentano una dashboard SPC con indici di capability e control chart, esportabili in PDF.
Caratteristiche principali:
- Recipe versioning condizionale (copy-on-write se esistono misurazioni, update in-place altrimenti)
- Calcolo pass/fail/warning su quattro limiti di tolleranza (UTL, UWL, LWL, LTL)
- SPC: Cp, Cpk, Pp, Ppk, control chart UCL/LCL, istogramma con curva normale — puro stdlib (no numpy)
- Annotazioni grafiche su disegni tecnici (Fabric.js) con viewer sincronizzato all'esecuzione
- Interfaccia completamente localizzata IT/EN, dark mode, ottimizzata per tablet touch
- Autenticazione API Key, rate limiting sliding window, audit log persistente
---
## Architettura ## Architettura
``` ```
Browser/Tablet → Reverse Proxy → Flask Client (:5000) → FastAPI Server (:8000) → MySQL 8.0 Browser/Tablet
|
Reverse Proxy (Nginx — sviluppo | Traefik+SSL — produzione)
|
Flask Client :5000 (rendering server-side, Jinja2 + Alpine.js)
| X-API-Key
FastAPI Server :8000 (API REST asincrona)
|
MySQL 8.0
``` ```
Due modalità di deployment: Il client Flask non espone mai le credenziali al browser: ogni chiamata al backend avviene server-side con l'header `X-API-Key` estratto dalla sessione Flask.
- **Sviluppo** (`docker-compose.dev.yml`): Nginx reverse proxy, porta 80
- **Produzione** (`docker-compose.yml`): Traefik reverse proxy con SSL automatico (Let's Encrypt)
Il sistema è composto da: ---
- **Flask Client**: Frontend tablet-oriented con rendering server-side
- **FastAPI Server**: Backend API REST con autenticazione via API key
- **MySQL 8.0**: Database relazionale per persistenza dati
## Stack Tecnologico ## Stack Tecnologico
### Backend (Server) ### Backend (server/)
- **FastAPI**: Framework asincrono per API REST
- **SQLAlchemy 2.0**: ORM con supporto async/await
- **asyncmy**: Driver MySQL asincrono
- **MySQL 8.0**: Database relazionale
- **Alembic**: Gestione migrazioni database
- **WeasyPrint**: Generazione report PDF da HTML
- **Kaleido**: Export grafici Plotly in formato SVG
### Frontend (Client) | Componente | Versione | Ruolo |
- **Flask 3.0**: Framework web per rendering server-side |---|---|---|
- **Jinja2**: Template engine | FastAPI | ultima stabile | Framework API REST asincrono |
- **Alpine.js 3.x**: Reattività leggera lato client | SQLAlchemy 2.0 | async | ORM con pool connessioni |
- **TailwindCSS 3.x**: Framework CSS utility-first | asyncmy | ultima stabile | Driver MySQL asincrono |
- **Plotly.js**: Libreria grafici interattivi | MySQL | 8.0 | Database relazionale |
- **Fabric.js 5.3.1**: Editor annotazioni su disegni tecnici | Alembic | ultima stabile | Migrazioni schema |
- **Flask-Babel**: Sistema i18n per IT/EN | Pydantic v2 | v2 | Validazione I/O |
| WeasyPrint | ultima stabile | Generazione report PDF |
| Kaleido | ultima stabile | Export grafici Plotly in SVG |
| bcrypt | ultima stabile | Hashing password |
| Pillow | ultima stabile | Thumbnail automatici upload |
### Sicurezza e Auth ### Frontend (client/)
- **API Key**: Autenticazione via header X-API-Key
- **Rate Limiting**: Protezione endpoint sensibili | Componente | Versione | Ruolo |
- **CORS**: Configurazione per deployment multi-dominio |---|---|---|
| Flask | 3.x | Framework web server-side |
| Jinja2 | incluso in Flask | Template engine |
| Alpine.js | 3.x (CDN) | Reattivita leggera lato client |
| TailwindCSS | 3.x | CSS utility-first |
| Plotly.js | CDN | Grafici SPC interattivi |
| Fabric.js | 5.3.1 (CDN) | Editor annotazioni disegni tecnici |
| Flask-Babel | ultima stabile | i18n IT/EN |
---
## Quick Start con Docker ## Quick Start con Docker
Il metodo raccomandato per installare e avviare TieMeasureFlow è tramite Docker Compose: Docker Compose è il metodo raccomandato. Gestisce database, migrazioni e configurazione Nginx in un solo comando.
```bash ```bash
# 1. Clone del repository # 1. Clona il repository
git clone <repository-url> git clone <repository-url>
cd TieMeasureFlow cd TieMeasureFlow
# 2. Configurazione ambiente # 2. Configura le variabili d'ambiente
cp .env.example .env cp .env.example .env
# Modifica .env con le tue credenziali (DB, password admin, ecc.) # Modifica .env: credenziali DB, chiavi segrete, SETUP_PASSWORD
# 3. Avvio dei servizi # 3. Avvia i servizi (ambiente di sviluppo)
docker compose -f docker-compose.dev.yml up -d # Sviluppo (Nginx, porta 80) docker compose -f docker-compose.dev.yml up -d
# oppure
docker compose up -d # Produzione (Traefik, SSL)
# 4. Setup iniziale # 4. Verifica lo stato dei container
docker compose -f docker-compose.dev.yml ps
# 5. Setup iniziale (solo al primo avvio)
# Apri http://localhost/api/setup nel browser # Apri http://localhost/api/setup nel browser
# Usa SETUP_PASSWORD configurata in .env per: # Usa SETUP_PASSWORD configurata in .env
# - Inizializzare il database
# - Creare l'utente admin
# - (Opzionale) Caricare dati demo
# 5. Accesso all'applicazione
# Apri http://localhost nel browser
# Login con credenziali admin create nel setup
``` ```
L'applicazione sarà disponibile su: L'applicazione sarà disponibile su:
- Frontend: http://localhost - Frontend: http://localhost
- API Backend: http://localhost/api - API: http://localhost/api
- Setup Page: http://localhost/api/setup - Pagina setup: http://localhost/api/setup
Per il deployment in produzione (Traefik + SSL) consulta [docs/DEPLOYMENT.md](docs/DEPLOYMENT.md).
---
## Setup Iniziale
Dopo il primo avvio, la pagina `/api/setup` (protetta da `SETUP_PASSWORD`) permette di:
- **Initialize Database** — crea tutte le tabelle
- **Create Admin User** — crea l'utente amministratore con credenziali da `.env`
- **Seed Demo Data** — carica ricette, misurazioni e utenti di esempio
- **Reset Database** — elimina e ricrea tutte le tabelle (attenzione: cancella tutti i dati)
- **Gestione utenti** — crea, modifica, attiva/disattiva account dalla stessa pagina
Se `SETUP_PASSWORD` è vuota o assente nel `.env`, l'endpoint è disabilitato.
---
## Setup Manuale (Senza Docker) ## Setup Manuale (Senza Docker)
Per chi preferisce installare senza Docker:
### Requisiti ### Requisiti
- Python 3.11 o superiore - Python 3.11 o superiore
- Node.js 18 o superiore - Node.js 18 o superiore
- MySQL 8.0 - MySQL 8.0
### Installazione ### 1. Database MySQL
#### 1. Database MySQL
```bash ```bash
# Crea database mysql -u root -p <<'SQL'
mysql -u root -p
CREATE DATABASE tiemeasureflow CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci; CREATE DATABASE tiemeasureflow CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'tielogic'@'localhost' IDENTIFIED BY 'your_password'; CREATE USER 'tielogic'@'localhost' IDENTIFIED BY 'your_password';
GRANT ALL PRIVILEGES ON tiemeasureflow.* TO 'tielogic'@'localhost'; GRANT ALL PRIVILEGES ON tiemeasureflow.* TO 'tielogic'@'localhost';
FLUSH PRIVILEGES; FLUSH PRIVILEGES;
SQL
``` ```
#### 2. Configurazione ### 2. Configurazione
```bash ```bash
# Copia template configurazione
cp .env.example .env cp .env.example .env
# Imposta DB_HOST, DB_USER, DB_PASSWORD, DB_NAME, SERVER_SECRET_KEY, CLIENT_SECRET_KEY, SETUP_PASSWORD
# Modifica .env con:
# - Credenziali database MySQL
# - Chiavi segrete
# - Password admin
``` ```
#### 3. Server (FastAPI Backend) ### 3. Server FastAPI
```bash ```bash
cd server cd server
# Crea virtual environment
python -m venv venv python -m venv venv
source venv/bin/activate # Su Windows: venv\Scripts\activate source venv/bin/activate # Windows: venv\Scripts\activate
# Installa dipendenze
pip install -r requirements.txt pip install -r requirements.txt
alembic -c migrations/alembic.ini upgrade head
# Esegui migrazioni database
alembic upgrade head
# Avvia server
uvicorn main:app --reload --host 0.0.0.0 --port 8000 uvicorn main:app --reload --host 0.0.0.0 --port 8000
``` ```
#### 4. Client (Flask Frontend) ### 4. Client Flask
```bash ```bash
cd client cd client
# Crea virtual environment
python -m venv venv python -m venv venv
source venv/bin/activate # Su Windows: venv\Scripts\activate source venv/bin/activate # Windows: venv\Scripts\activate
# Installa dipendenze
pip install -r requirements.txt pip install -r requirements.txt
# Build TailwindCSS
npx tailwindcss -i static/css/input.css -o static/css/tailwind.css --watch
# In un altro terminale: Compila traduzioni
cd client
pybabel compile -d translations pybabel compile -d translations
# Avvia client
flask run --host 0.0.0.0 --port 5000 flask run --host 0.0.0.0 --port 5000
``` ```
Accesso: ### 5. TailwindCSS (watch per sviluppo)
```bash
cd client
npx tailwindcss -i static/css/input.css -o static/css/tailwind.css --watch
```
Accesso diretto (senza Nginx):
- Frontend: http://localhost:5000 - Frontend: http://localhost:5000
- Backend API: http://localhost:8000 - API: http://localhost:8000
## Pagina di Setup ---
TieMeasureFlow include una pagina di setup protetta accessibile su `/api/setup`: ## Ruoli Utente
- **Protezione**: Richiede SETUP_PASSWORD configurata in .env I ruoli sono combinabili (array JSON per utente). Il flag `is_admin` è separato dai ruoli funzionali.
- **Disabilitazione**: Se SETUP_PASSWORD è vuota/assente, endpoint disabilitato
- **Accesso**:
- Via nginx (produzione): http://localhost/api/setup
- Diretto (sviluppo): http://localhost:8000/api/setup
### Funzionalità Setup | Ruolo | Descrizione |
- **Initialize Database**: Crea tutte le tabelle necessarie |---|---|
- **Create Admin User**: Crea utente amministratore con credenziali da .env | **Maker** | Crea e gestisce ricette di misurazione: caricamento disegni (PDF/immagini), annotazioni Fabric.js, definizione task/subtask, configurazione tolleranze, versioning copy-on-write |
- **Seed Demo Data**: Carica dati di esempio (ricette, misurazioni, utenti) | **MeasurementTec** | Esegue misurazioni: scansione barcode per selezione ricetta, interfaccia task-driven, input da calibro USB HID o numpad touch, validazione real-time pass/warning/fail |
- **Reset Database**: Elimina e ricrea tutte le tabelle (attenzione: cancella tutti i dati!) | **Metrologist** | Analisi qualità: dashboard SPC (X-bar, R, Cp, Cpk, Pp, Ppk), filtri multi-dimensionali, export report PDF, analisi capability e control chart |
| **Admin** (flag) | Gestione sistema: CRUD utenti, cambio password, attivazione/disattivazione account |
---
## Struttura Progetto ## Struttura Progetto
``` ```
TieMeasureFlow/ TieMeasureFlow/
├── server/ # FastAPI Backend (API REST) ├── server/ # FastAPI Backend
│ ├── main.py # Entry point applicazione │ ├── main.py # Entry point, lifespan, middleware, 10 router
│ ├── config.py # Configurazione da variabili .env │ ├── config.py # Settings (pydantic_settings.BaseSettings)
│ ├── database.py # SQLAlchemy async engine e sessioni │ ├── database.py # SQLAlchemy 2.0 async engine
│ ├── models/ # ORM models (User, Recipe, Measurement, ecc.) │ ├── models/ # ORM: User, Recipe, RecipeVersion, RecipeTask,
│ ├── schemas/ # Pydantic schemas per validazione I/O │ │ # RecipeSubtask, Measurement, AccessLog,
│ ├── routers/ # API endpoints organizzati per dominio │ │ # SystemSetting, RecipeVersionAudit
│ ├── services/ # Business logic (SPC, PDF, auth, ecc.) │ ├── schemas/ # Pydantic v2 per validazione I/O API
│ ├── middleware/ # Auth, logging, rate limiting │ ├── routers/ # auth, users, recipes, tasks, measurements,
│ ├── migrations/ # Alembic migration scripts │ │ # files, settings, statistics, reports, setup
│ └── templates/ # Template HTML per setup page │ ├── services/ # recipe_service, measurement_service,
├── client/ # Flask Frontend (UI tablet) │ │ # spc_service, report_service, auth_service
│ ├── app.py # Entry point applicazione │ ├── middleware/ # api_key, rate_limit, security_headers, logging
│ ├── blueprints/ # Route blueprints (auth, maker, measure, statistics, admin) │ ├── migrations/ # Alembic (alembic.ini + env.py)
│ ├── services/ # API client wrapper per chiamate a FastAPI │ └── templates/ # Template HTML pagina setup
│ ├── templates/ # Jinja2 templates per rendering pagine ├── client/ # Flask Frontend
│ ├── static/ # Asset statici (CSS, JS, immagini) │ ├── app.py # Factory pattern, CSRF, Babel
│ │ ├── css/ # TailwindCSS compiled output │ ├── blueprints/ # auth, maker, measure, statistics, admin
│ │ ├── js/ # Alpine.js components e utility │ ├── services/ # APIClient singleton (proxy verso FastAPI)
│ │ └── images/ # Loghi, icone, placeholder │ ├── templates/ # Jinja2 + Alpine.js
│ └── translations/ # File i18n per IT/EN (Flask-Babel) │ ├── static/
├── nginx/ # Configurazione reverse proxy (dev) │ │ ├── css/ # TailwindCSS compilato
│ └── nginx.conf # Routing unificato client/server │ │ └── js/ # numpad, caliper, barcode, csv-export,
├── docker-compose.yml # Produzione (Traefik, SSL) │ │ # spc-charts, annotation-editor/viewer
├── docker-compose.dev.yml # Sviluppo (Nginx, porta 80) │ └── translations/ # Flask-Babel .po/.mo IT/EN
├── .env.example # Template variabili d'ambiente ├── nginx/ # Configurazione Nginx (dev)
└── docs/ # Documentazione tecnica ├── docs/ # Documentazione tecnica
│ ├── API.md # Riferimento API REST
│ ├── DEPLOYMENT.md # Guida deployment VPS (Traefik, SSL, DNS)
│ └── USER_GUIDE.md # Manuale utente per ruolo
├── docker-compose.yml # Produzione (Traefik, SSL)
├── docker-compose.dev.yml # Sviluppo (Nginx, porta 80)
└── .env.example # Template variabili d'ambiente
``` ```
## Ruoli Utente ---
TieMeasureFlow supporta tre ruoli principali, combinabili:
### Maker
Responsabile della creazione e modifica delle ricette di misurazione:
- Caricamento disegni tecnici (PDF)
- Annotazioni grafiche con Fabric.js (linee, frecce, testi, ellissi)
- Definizione task e subtask di misurazione
- Configurazione tolleranze (UTL, UWL, LWL, LTL)
- Gestione versioni immutabili (copy-on-write)
### MeasurementTec
Operatore che esegue le misurazioni:
- Accesso rapido via barcode scanner
- Interfaccia task-driven per guida passo-passo
- Input valori da calibro USB HID (rilevamento automatico burst)
- Validazione real-time pass/fail su tolleranze
- Salvataggio annotazioni fotografiche
### Metrologist
Analista qualità con accesso alle statistiche:
- Dashboard SPC con grafici Plotly.js (X-bar, R, Cp, Cpk)
- Filtri multi-dimensionali (ricetta, utente, periodo, stato)
- Export report PDF con WeasyPrint
- Analisi tendenze e capability del processo
I ruoli sono configurabili in fase di creazione utente e possono essere combinati. Flag `is_admin` separato per gestione sistema (CRUD utenti, cambio password, attivazione/disattivazione account).
## Guida VPS Deployment
### Requisiti VPS
- 2GB RAM minimo (4GB raccomandati)
- 20GB spazio disco
- Ubuntu 22.04 LTS o superiore
- Accesso SSH con privilegi sudo
### Installazione Docker
```bash
# Installa Docker
curl -fsSL https://get.docker.com | sh
# Aggiungi utente al gruppo docker
sudo usermod -aG docker $USER
# Installa Docker Compose (se non incluso)
sudo apt update
sudo apt install docker-compose-plugin
# Ricarica gruppi (oppure logout/login)
newgrp docker
```
### Deploy Applicazione
Il compose di produzione (`docker-compose.yml`) usa Traefik come reverse proxy con SSL automatico. Richiede un'istanza Traefik già configurata con rete Docker `root_default`.
```bash
# Clone repository
git clone <repository-url>
cd TieMeasureFlow
# Configura ambiente (IMPORTANTE: usa password sicure!)
cp .env.example .env
nano .env
# Modifica almeno:
# - DB_ROOT_PASSWORD
# - DB_PASSWORD
# - SERVER_SECRET_KEY
# - CLIENT_SECRET_KEY
# - SETUP_PASSWORD
# Avvia servizi (produzione con Traefik)
docker compose up -d
# Verifica stato
docker compose ps
docker compose logs -f
```
### Configurazione Firewall
```bash
# Abilita UFW
sudo ufw allow OpenSSH
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw enable
# Verifica regole
sudo ufw status
```
### Configurazione DNS
1. Accedi al pannello del tuo provider DNS
2. Crea un record A che punta il tuo dominio all'IP pubblico del VPS:
```
Type: A
Name: @ (o www)
Value: <VPS_IP>
TTL: 3600
```
3. Attendi propagazione DNS (5-30 minuti)
### SSL (HTTPS)
Il compose di produzione usa Traefik con Let's Encrypt per certificati SSL automatici. Configurare il dominio nelle labels Traefik di `docker-compose.yml`.
Per ambienti senza Traefik (compose dev con Nginx), configurare SSL manualmente:
- Impostare `SSL_CERTFILE` e `SSL_KEYFILE` in `.env`
- Decommentare le righe SSL in `nginx/nginx.conf`
## Comandi Utili ## Comandi Utili
> **Nota:** Per sviluppo locale aggiungere `-f docker-compose.dev.yml` ai comandi docker compose. ### Docker
| Comando | Descrizione | | Comando | Descrizione |
|---------|-------------| |---|---|
| `docker compose up -d` | Avvia tutti i servizi in background | | `docker compose -f docker-compose.dev.yml up -d` | Avvia servizi in sviluppo |
| `docker compose down` | Ferma e rimuove tutti i container | | `docker compose -f docker-compose.dev.yml down` | Ferma e rimuove i container |
| `docker compose logs -f server` | Segui log del server in tempo reale | | `docker compose logs -f server` | Segui log server in tempo reale |
| `docker compose logs -f client` | Segui log del client in tempo reale | | `docker compose logs -f client` | Segui log client in tempo reale |
| `docker compose ps` | Mostra stato di tutti i servizi | | `docker compose ps` | Stato di tutti i servizi |
| `docker compose exec server alembic -c migrations/alembic.ini upgrade head` | Esegui migrazioni database | | `docker compose build --no-cache` | Ricostruisci immagini senza cache |
| `docker compose exec server alembic -c migrations/alembic.ini revision --autogenerate -m "desc"` | Genera nuova migrazione | | `docker compose exec mysql mysql -u root -p tiemeasureflow` | CLI MySQL |
| `docker compose build --no-cache` | Ricostruisci tutte le immagini senza cache |
| `docker compose exec mysql mysql -u root -p tiemeasureflow` | Accedi alla CLI MySQL |
## Sviluppo ### Alembic (migrations)
### Hot Reload Nota: `alembic.ini` si trova dentro `server/migrations/`, è richiesto il flag `-c`.
- Server FastAPI: Uvicorn con `--reload` flag (automatico in docker-compose)
- Client Flask: Flask debug mode (automatico in docker-compose)
- TailwindCSS: `--watch` flag per rebuild automatico
### Migrazioni Database
```bash ```bash
cd server cd server
alembic -c migrations/alembic.ini upgrade head # Applica migrazioni
# Genera nuova migrazione alembic -c migrations/alembic.ini revision --autogenerate -m "descrizione" # Genera migrazione
alembic -c migrations/alembic.ini revision --autogenerate -m "Descrizione modifica" alembic -c migrations/alembic.ini downgrade -1 # Rollback ultima
# Applica migrazioni
alembic -c migrations/alembic.ini upgrade head
# Rollback ultima migrazione
alembic -c migrations/alembic.ini downgrade -1
``` ```
### Testing Via Docker:
```bash ```bash
# Server (SQLite in-memory, no MySQL richiesto) docker compose exec server alembic -c migrations/alembic.ini upgrade head
cd server && pytest # Tutti i test ```
### i18n (Traduzioni)
```bash
cd client
pybabel extract -F babel.cfg -k _ -o translations/messages.pot . # Estrai stringhe
pybabel update -i translations/messages.pot -d translations # Aggiorna catalogo
pybabel compile -d translations # Compila .po → .mo
```
---
## Testing
Il server usa SQLite in-memory tramite `aiosqlite`: i test girano senza MySQL installato.
```bash
# Server
cd server && pytest # Tutti i test
cd server && pytest tests/test_auth.py # Singolo modulo cd server && pytest tests/test_auth.py # Singolo modulo
cd server && pytest tests/test_auth.py::test_login_success # Singolo test cd server && pytest tests/test_auth.py::test_login_success # Singolo test
cd server && pytest --cov # Con copertura cd server && pytest --cov # Con copertura
@@ -366,6 +289,39 @@ cd server && pytest --cov # Con copertura
cd client && pytest cd client && pytest
``` ```
---
## Variabili d'Ambiente
Copia `.env.example` in `.env` e configura:
| Variabile | Descrizione |
|---|---|
| `DB_HOST`, `DB_PORT`, `DB_NAME` | Connessione MySQL |
| `DB_USER`, `DB_PASSWORD` | Credenziali utente MySQL |
| `DB_ROOT_PASSWORD` | Password root MySQL (solo Docker) |
| `SERVER_SECRET_KEY` | Chiave segreta FastAPI |
| `SERVER_CORS_ORIGINS` | Origini CORS ammesse |
| `CLIENT_SECRET_KEY` | Chiave segreta Flask (sessioni, CSRF) |
| `API_SERVER_URL` | URL del backend visto dal client (es. `http://server:8000`) |
| `UPLOAD_DIR` | Percorso upload file (default: `uploads`, relativo a `server/`) |
| `MAX_UPLOAD_SIZE_MB` | Limite dimensione upload |
| `NGINX_PORT`, `NGINX_SSL_PORT` | Porte Nginx (solo compose dev) |
| `SETUP_PASSWORD` | Password pagina setup (vuota = endpoint disabilitato) |
| `SSL_CERTFILE`, `SSL_KEYFILE` | Certificato SSL (solo setup manuale) |
---
## Documentazione
| Documento | Contenuto |
|---|---|
| [docs/API.md](docs/API.md) | Riferimento completo API REST (endpoint, parametri, schemi) |
| [docs/DEPLOYMENT.md](docs/DEPLOYMENT.md) | Guida deployment VPS: Docker, Traefik, SSL, DNS, firewall |
| [docs/USER_GUIDE.md](docs/USER_GUIDE.md) | Manuale utente per ruolo (Maker, MeasurementTec, Metrologist) |
---
## Licenza ## Licenza
Proprietary - Tielogic. All rights reserved. Proprietary - Tielogic. All rights reserved.