Laboratorio didattico per progettare, sviluppare e governare un'applicazione web full-stack con agenti AI, workflow Man-in-the-Loop e metodologia Iterativo-Incrementale.
Panoramica · Perché Esiste · Workflow · Funzionalità · Documenti · Valore Didattico · Avvio Rapido · Deploy su Azure · Struttura · License
CineBase è un progetto didattico realizzato presso l'Istituto Alessandro Greppi di Monticello Brianza (corso di Informatica) come laboratorio di programmazione automatica assistita da agenti AI. L'obiettivo non è solo produrre un'applicazione funzionante, ma mostrare come usare agenti AI senza perdere il controllo su analisi, pianificazione, review, testing e documentazione.
La piattaforma implementa un sistema completo di ticketing per cinema multisala: catalogo film, programmazione, selezione posti, acquisto biglietti (Stripe + credito interno), validazione ingressi, dashboard amministrativa e gestione utenti con RBAC a quattro ruoli.
È in produzione su www.cinebase.it
| Area | Contenuto | Link |
|---|---|---|
| Prodotto | Architettura, componenti, stack tecnologico, topologie di deploy | docs/dev_notes/architecture.md |
| Pianificazione | Piani di lavoro iterativi (13 iterazioni), changelog, status | docs/project/dev_iteration/ |
| Prompt Log | Prompt originali usati per generare i Piani di Lavoro via AI | docs/project/prompt_log/ |
| Metodo | Processo di sviluppo: Iterativo-Incrementale, Agile, FDD, GitHub Flow, ruolo AI | docs/method/processo-di-sviluppo.md |
| Manuali Utente | Manuali per utente standard, CinemaStaff, Admin/PowerUser | docs/user_manuals/ |
| Test | Tipologie di test, harness, comandi per backend e frontend (639 backend + ~160 frontend) | docs/dev_notes/tests.md |
| Note Tecniche | Documentazione sintetica per sviluppatori (backend, DB, frontend, auth, Docker, deploy) | docs/dev_notes/ |
Nel contesto didattico del progetto, l'AI non viene trattata come un generatore automatico di codice già pronto. Viene usata come collaboratore all'interno di un processo controllato, dove lo studente mantiene piena responsabilità su ogni decisione.
Questo repository dimostra come:
- Trasformare un'idea applicativa in un Piano di Lavoro strutturato e verificabile
- Suddividere lo sviluppo in iterazioni brevi con scope, attività e criteri di accettazione chiari
- Usare prompt ingegnerizzati come surrogato di User Stories ed Epiche
- Delegare a un Agente AI l'implementazione meccanica, mantenendo allo studente le decisioni architetturali, la review e la validazione finale
- Applicare metodologie software reali (Agile, FDD, GitHub Flow) in un progetto concreto, non simulato
- Costruire una suite di test crescente (da 0 a 639 test backend xUnit + ~160 test frontend Playwright) come rete di sicurezza per refactoring e iterazioni successive
- Produrre documentazione vivente aggiornata a ogni iterazione (changelog, status, piani di lavoro, manualistica utente)
- Portare l'applicazione fino al deploy in produzione su cloud Azure con domini reali, TLS, autenticazione OAuth e pagamenti Stripe
Il progetto segue un ciclo operativo a cinque fasi, ispirato al modello Man-in-the-Loop e governato dal PianoDiLavoro.md di ogni iterazione:
flowchart LR
subgraph Planning["1. Pianificazione"]
Prompt["Prompt ingegnerizzato<br/>(User Story / Epic)"]
Analisi["AI Pianificatore<br/>analizza contesto"]
Piano["PianoDiLavoro.md<br/>(Sprint Backlog)"]
Prompt --> Analisi --> Piano
end
subgraph Build["2. Sviluppo"]
Agente["Agente AI<br/>implementa codice"]
Test["Test automatici<br/>(xUnit + Playwright)"]
Agente --> Test
end
subgraph Review["3. Review"]
Umana["Validazione umana<br/>codice, stile, sicurezza"]
end
subgraph Docs["4. Documentazione"]
Aggiorna["changelog.md<br/>status.md<br/>manuali"]
end
subgraph Git["5. Git"]
Merge["Merge su main<br/>branch chiuso"]
end
Planning --> Build
Build --> Review
Review --> Docs
Docs --> Git
Git -->|"iterazione successiva"| Planning
-
Pianificazione — Un prompt narrativo descrive requisiti funzionali e non funzionali dal punto di vista dell'utente. Un AI Pianificatore analizza il contesto (codice esistente, changelog, status) e produce un
PianoDiLavoro.mdstrutturato in fasi numerate, con attività, file da creare/modificare, test da scrivere e criteri di accettazione. -
Sviluppo — Il Piano di Lavoro viene affidato a un Agente AI specializzato nel coding. L'agente esplora il codebase, implementa le modifiche, scrive i test, esegue la suite e corregge eventuali regressioni in ciclo chiuso.
-
Review — Lo studente revisiona il codice prodotto: correttezza funzionale, aderenza allo stile del progetto, sicurezza, performance. Le decisioni architetturali strategiche rimangono sempre in capo allo studente.
-
Documentazione — A iterazione completata, changelog e status del progetto vengono aggiornati. La documentazione tecnica e la manualistica utente evolvono insieme al codice.
-
Git — Il branch dell'iterazione viene mergiato su
main, che rappresenta sempre lo stato stabile e testato del software.
Un'iterazione si considera completata solo quando:
- Tutti i test automatici passano (639 backend xUnit + ~160 frontend Playwright)
- La suite di test si espande (mai regressione nel conteggio)
- Il branch è mergiato su
main - La documentazione di progetto è aggiornata
- I flussi principali sono verificati manualmente
Il progetto segue GitHub Flow con main come unico branch stabile. Ogni iterazione è sviluppata in un feature branch e mergiata al termine. Non esistono branch develop o release di lunga durata. I commit usano messaggi strutturati che riepilogano modifiche, file e numero di test passanti.
- Home page con carosello film in evidenza e accesso rapido alla programmazione
- Programmazione film con tab (In evidenza, In uscita, Tutti), ricerca, filtro per categoria, selezione cinema con geolocalizzazione
- Scheda film con copertina, trailer, cast, descrizione, date rail, orari raggruppati per tipo sala (2D, 3D, ISENSE, XL)
- Lista cinema con ricerca, ordinamento per distanza, programmazione giornaliera
- Pagine legali (Privacy, Cookie, Termini e Condizioni)
- Registrazione con email e password (con validazione forza password) o social login (Google / Microsoft)
- Login con JWT (access token in memoria, refresh token in cookie HTTP-only
SameSite=Strict) - Recupero password via email con anti-enumerazione
- Cambio password con invalidazione massiva dei token esistenti
- Profilo personale: dati anagrafici, sicurezza, credito, storico ordini e biglietti
- Acquisto biglietti: selezione posti interattiva con hold temporizzato (10 min), pagamento via Stripe Checkout, credito interno, o misto
- Biglietti digitali: PDF multipagina con codice a barre, invio email automatico, download dal profilo
- GDPR: esportazione dati personali, cancellazione account con anonimizzazione selettiva, disabilitazione account
- Validazione biglietti all'ingresso: ricerca per codice, scansione barcode, modalità auto-click per uso con scanner
- Ricarica credito utenti con audit trail
- Gestione show per i cinema di competenza: creazione, modifica, pianificazione batch
- Dashboard con KPI, grafici ricavi (Chart.js con zoom/export), classifica top film
- Gestione film: CRUD, import da TMDB, upload copertine
- Gestione registi, categorie, sale con editor visuale del layout posti
- Gestione show per tutti i cinema: CRUD, pianificazione batch, annullamento con rimborsi automatici e revisione manuale
- Gestione utenti (Admin): invito, cambio ruolo, assegnazione cinema per staff, disabilitazione, esportazione GDPR
- Rimborsi: dashboard revisioni manuali, approvazione/rifiuto/rimborso parziale
- Impostazioni piattaforma (Admin): prezzi base, percentuali VIP/Access, buffer show
| Layer | Tecnologia |
|---|---|
| Backend | ASP.NET Core 10 Minimal API, Entity Framework Core, Pomelo MySQL |
| Database | MariaDB 10.11 |
| Frontend | HTML5, CSS3, JavaScript vanilla, Tailwind CSS 3.4 |
| Autenticazione | JWT HS256, BCrypt, OAuth 2.0 + OIDC + PKCE (Google, Microsoft) |
| Pagamenti | Stripe Checkout (hosted), credito interno, pagamento misto |
| Testing | xUnit, FluentAssertions, Moq, Playwright (Chromium/Edge) |
| Container | Docker, Docker Compose, multi-stage builds |
| Cloud | Azure Container Apps, Azure Container Registry, Azure Files |
| Monitoraggio | Health checks, readiness probe, Log Analytics |
| Documento | Scopo |
|---|---|
docs/method/processo-di-sviluppo.md |
Metodo completo: Iterativo-Incrementale, Agile, FDD, GitHub Flow, ruolo AI |
docs/project/changelog.md |
Cronologia dettagliata di tutte le modifiche per iterazione |
docs/project/status.md |
Stato corrente del progetto, riepilogo sessioni completate |
docs/project/dev_iteration/ |
13 Piani di Lavoro (IT1 → IT6 con sotto-iterazioni) |
docs/project/prompt_log/ |
6 prompt originali usati per generare i Piani di Lavoro |
docs/dev_notes/architecture.md |
Architettura generale: componenti, diagrammi, stack |
docs/dev_notes/backend.md |
Backend: Program.cs, servizi, endpoint, autenticazione, rate limiting |
docs/dev_notes/database.md |
Modello dati, entità, relazioni, seeding |
docs/dev_notes/frontend.md |
Frontend: pagine, moduli JS, componenti, routing |
docs/dev_notes/authentication.md |
Flussi di autenticazione: JWT, refresh, social login |
docs/dev_notes/stripe-checkout.md |
Flussi di pagamento: hold, ordini, Stripe, credito |
docs/dev_notes/docker.md |
Containerizzazione: Dockerfile, Compose, multi-stage |
docs/dev_notes/deployment-aca.md |
Deploy su Azure Container Apps |
docs/dev_notes/tests.md |
Suite di test: tipologie, harness, comandi |
docs/user_manuals/standard_user.md |
Manuale per l'utente standard (pubblico + registrato) |
docs/user_manuals/cinema_staff.md |
Manuale per il personale di sala |
docs/user_manuals/admin_power_user.md |
Manuale per amministratori e power user |
Il progetto costituisce un ponte concreto tra formazione scolastica e mondo professionale. Gli studenti che lavorano su CineBase sperimentano:
| Competenza | Come viene esercitata |
|---|---|
| Lavoro in cicli iterativi | 13 iterazioni con scope, stima, esecuzione e verifica — lo stesso ritmo di uno Sprint aziendale |
| Uso professionale dell'AI | L'AI non è un sostituto ma un acceleratore: lo studente impara a delegare, verificare e integrare |
| Code review e qualità | 639 test backend + ~160 test frontend come rete di sicurezza; Definition of Done rigorosa; refactoring senza paura |
| DevOps e Cloud | Docker, Azure Container Apps, domini reali, TLS, CI implicito via test |
| Sicurezza applicativa | JWT, BCrypt, OAuth 2.0 PKCE, CSP, XSS prevention, RBAC, rate limiting, GDPR |
| Documentazione professionale | Piani di lavoro, changelog, manuali utente, documentazione tecnica — tutto in italiano corretto e strutturato |
| Gestione del debito tecnico | Iterazioni dedicate alla pulizia (4.1, 5.1) invece di accumulare complessità |
| ** Full-stack reale** | Non un toy project: database, API, frontend, pagamenti, container, cloud |
CineBase offre agli studenti delle scuole superiori una finestra privilegiata sulle professioni digitali:
- Software Developer: esposizione all'intero stack di sviluppo — backend, frontend, database, API design, test automation
- DevOps Engineer: containerizzazione, orchestrazione, deploy cloud, monitoraggio, health checks
- Product Manager / Business Analyst: traduzione di requisiti di business in piani di lavoro, stima, prioritizzazione
- UX/UI Designer: design system, temi chiaro/scuro, componenti riusabili, responsive design
- Security Specialist: autenticazione, autorizzazione, crittografia, penetration testing (CSP, XSS), GDPR
Il progetto dimostra che lo sviluppo software moderno è una disciplina integrata: non basta saper scrivere codice, occorre padroneggiare metodo, strumenti, processo e comunicazione.
| Metrica | Valore |
|---|---|
| Iterazioni completate | 13 (6 principali + 7 sotto-iterazioni) |
| Test automatici | ~800 (639 backend xUnit + ~160 frontend Playwright) |
| Endpoint API | ~105 |
| Entità database | 30+ |
| Ruoli utente RBAC | 4 (User, CinemaStaff, PowerUser, Admin) |
| Pagine frontend | 31 |
| Fasi di implementazione totali | 120+ |
| Tecnologie utilizzate | 15+ |
- Docker Desktop (Windows/macOS) o Docker Engine (Linux)
- .NET 10 SDK (per sviluppo backend)
- Node.js 22+ (per sviluppo frontend e test Playwright)
# Clona il repository
git clone https://github.com/GreppiDev/CineBase.git
cd CineBase
# Avvio di base (MariaDB, API, frontend, seeder, Mailpit)
# Nessun servizio esterno configurato: solo esplorazione e acquisto con credito
docker compose --env-file .env.docker.example up -d --build
# L'app sarà disponibile su:
# Frontend: http://localhost:5001
# Backend: http://localhost:5000/swagger
# Mailpit: http://localhost:8025Per abilitare Stripe, Google/Microsoft Login e invio email SMTP reale, crea un file .env.docker nella root del progetto con le variabili d'ambiente necessarie. Docker Compose legge prima .env.docker.example (valori predefiniti) e poi .env.docker (override personali):
# Avvio completo con servizi esterni configurati
docker compose --env-file .env.docker.example --env-file .env.docker up -d --buildIl file .env.docker non è tracciato da Git (aggiunto a .gitignore) e deve contenere solo le variabili che vuoi sovrascrivere:
# ─── STRIPE (pagamenti con carta) ──────────────────────────────────
# Ottieni le chiavi da https://dashboard.stripe.com/test/apikeys
STRIPE_SECRET_API_KEY=sk_test_xxxxxxxxxxxxxxxxxxxx
STRIPE_API_KEY=sk_test_xxxxxxxxxxxxxxxxxxxx
STRIPE_PUBLISHABLE_API_KEY=pk_test_xxxxxxxxxxxxxxxxxxxx
STRIPE_PUBLISHABLE_KEY=pk_test_xxxxxxxxxxxxxxxxxxxx
STRIPE_WEBHOOK_SECRET=whsec_xxxxxxxxxxxxxxxxxxxx
# ─── GOOGLE OAUTH (login con Google) ───────────────────────────────
# Crea le credenziali OAuth 2.0 su https://console.cloud.google.com/apis/credentials
# Redirect URI autorizzato: http://localhost:5000/auth/external/google/callback
GOOGLE_OAUTH_CLIENT_ID=xxxxxxxxxx.apps.googleusercontent.com
GOOGLE_OAUTH_CLIENT_SECRET=GOCSPX-xxxxxxxxxxxxxxxxxxxx
# ─── MICROSOFT OAUTH (login con Microsoft) ─────────────────────────
# Registra l'app su https://portal.azure.com/#view/Microsoft_AAD_RegisteredApps
# Redirect URI autorizzato: http://localhost:5000/auth/external/microsoft/callback
MICROSOFT_OAUTH_CLIENT_ID=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
MICROSOFT_OAUTH_CLIENT_SECRET=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# ─── SMTP REALE (invio email) ─────────────────────────────────────
# Sostituisce Mailpit con un server SMTP reale (es. Gmail, Aruba, SendGrid)
# Per sviluppo locale, Mailpit è già configurato e non richiede override
SMTP_HOST=smtp.gmail.com
SMTP_PORT=587
SMTP_USER=tua-email@gmail.com
SMTP_PASSWORD=xxxxxxxxxxxxxxxx
SMTP_REQUIRE_AUTH=true
SMTP_SECURE_SOCKET_OPTIONS=StartTls
SMTP_FROM_EMAIL=noreply@cinebase.it
SMTP_FROM_NAME=CineBaseDopo aver creato .env.docker, esegui di nuovo docker compose --env-file .env.docker.example --env-file .env.docker up -d --build per ricostruire i container con le nuove variabili.
# Backend
cd backend/FilmAPI
cp .env.example .env
dotnet run
# Frontend (in un altro terminale)
cd frontend/CineBase.Web
dotnet run# Tutti i test backend (639 test xUnit)
dotnet test tests/backend/FilmAPI.Tests.csproj
# Test frontend Playwright (browser installato, ~160 test)
cd frontend/CineBase.Web
npm run test:browser
# Test E2E in container Docker
docker compose -f docker-compose.yml -f docker-compose.e2e.yml --env-file .env.docker.example --profile e2e run --rm --build playwrightCineBase è in produzione su Azure Container Apps (region italynorth) con domini reali e certificati TLS gestiti automaticamente.
Resource Group: rg-cinebase-aca Region: italynorth
ACR: crcinebaseaca (Basic)
├── filmapi
├── cinebase-web
└── cinebase-redirect
ACA Environment: cae-cinebase (static IP)
├── mariadb [INTERNAL, TCP 3306]
│ Volume: mariadb-data → /var/lib/mysql
├── filmapi [EXTERNAL, HTTPS] → api.cinebase.it
│ Volume: media-uploads → /app/wwwroot/media/covers
├── cinebase-web [EXTERNAL, HTTPS] → www.cinebase.it
├── cinebase-redirect [EXTERNAL, HTTPS] → cinebase.it (301 → www)
└── filmapi-seeder [JOB, manual trigger]
Storage Account: stcinebaseaca
├── File Share: mariadb-data (Azure Files)
└── File Share: media-uploads (Azure Files)
Managed Identity: id-cinebase-aca (AcrPull)
Log Analytics: log-cinebase-aca
Gli script PowerShell nella cartella infra/azure/aca/ automatizzano l'intero deployment:
| Script | Fase | Descrizione |
|---|---|---|
01-provision-infra.ps1 |
FASE 8 | Provisioning: RG, ACR, Log Analytics, ACA Environment, Storage, Managed Identity, build e push Docker images |
10-deploy-mariadb.ps1 |
FASE 9 | Deploy MariaDB con Azure Files per persistenza dati |
20-deploy-filmapi.ps1 |
FASE 10 | Deploy backend FilmAPI + seeder job |
40-deploy-frontend.ps1 |
FASE 11 | Deploy frontend CineBase.Web |
50-configure-custom-domains.ps1 |
FASE 12 | Configura domini personalizzati, TLS, OAuth, SMTP, Stripe |
51-deploy-redirect.ps1 |
FASE 12 | Deploy container redirect apex cinebase.it → www.cinebase.it |
99-smoke.ps1 |
FASE 13 | Smoke test post-deploy |
# 1. Prerequisito: crea infra/azure/aca/00-variables.ps1 dal template
cp infra/azure/aca/00-variables.example.ps1 infra/azure/aca/00-variables.ps1
# Compila con i valori reali (password, chiavi API, segreti OAuth)
# 2. Provisioning infrastruttura + build e push immagini Docker
.\infra\azure\aca\01-provision-infra.ps1 -SkipConfirmation
# 3. Deploy MariaDB
.\infra\azure\aca\10-deploy-mariadb.ps1 -SkipConfirmation
# 4. Deploy backend FilmAPI + seeder job
.\infra\azure\aca\20-deploy-filmapi.ps1 -SkipConfirmation
# 5. Avvia seeder per popolare il database
az containerapp job start --name filmapi-seeder --resource-group rg-cinebase-aca
# 6. Deploy frontend
.\infra\azure\aca\40-deploy-frontend.ps1 -SkipConfirmation
# 7. Configura domini, TLS, OAuth, SMTP, Stripe
.\infra\azure\aca\50-configure-custom-domains.ps1 -SkipConfirmation
# 8. (Opzionale) Deploy redirect apex
.\infra\azure\aca\51-deploy-redirect.ps1 -SkipConfirmation
# 9. Verifica smoke test
.\infra\azure\aca\99-smoke.ps1Il deploy non ha CI/CD. Per aggiornare backend o frontend:
# Build, tag univoco, push su ACR, aggiorna Container App
$ts = Get-Date -Format "yyyyMMddHHmmss"
# Aggiorna backend
docker build -t filmapi:$ts -f backend/FilmAPI/Dockerfile .
docker tag filmapi:$ts crcinebaseaca.azurecr.io/filmapi:$ts
docker push crcinebaseaca.azurecr.io/filmapi:$ts
az containerapp update --name filmapi --resource-group rg-cinebase-aca --image crcinebaseaca.azurecr.io/filmapi:$ts
# Aggiorna frontend
docker build -t cinebase-web:$ts -f frontend/CineBase.Web/Dockerfile .
docker tag cinebase-web:$ts crcinebaseaca.azurecr.io/cinebase-web:$ts
docker push crcinebaseaca.azurecr.io/cinebase-web:$ts
az containerapp update --name cinebase-web --resource-group rg-cinebase-aca --image crcinebaseaca.azurecr.io/cinebase-web:$ts# Elenca le revisioni disponibili
az containerapp revision list --name filmapi --resource-group rg-cinebase-aca -o table
# Attiva una revisione precedente
az containerapp revision activate --name filmapi --resource-group rg-cinebase-aca --revision filmapi--0000011| Servizio | Provider | Dettaglio |
|---|---|---|
| Database | MariaDB 10.11 su ACA | Volume Azure Files, film-api-db |
| SMTP | Aruba | smtps.aruba.it:465 (SslOnConnect), noreply@cinebase.it |
| Google OAuth | Google Cloud | Client ID/Secret, redirect: https://api.cinebase.it/auth/external/google/callback |
| Microsoft OAuth | Microsoft Entra ID | Client ID/Secret, authority: common, redirect: https://api.cinebase.it/auth/external/microsoft/callback |
| Stripe | Stripe (test mode) | Webhook: https://api.cinebase.it/payments/stripe/webhook |
| DNS | Aruba | Record A apex → ACA IP, CNAME www/api → ACA FQDN |
| TLS | Azure (Let's Encrypt) | Provisioning automatico tramite Managed Certificate |
docs/dev_notes/deployment-aca.md— Panoramica architetturale del deploydocs/project/dev_iteration/6/GuidaDeploymentACA.md— Guida completa (697 righe)docs/project/dev_iteration/6/TutorialCicloSviluppoDeployACASenzaCICD.md— Ciclo sviluppo→deploy senza CI/CD (1325+ righe)docs/project/dev_iteration/6/TutorialDeploymentACAReale_PassoPasso.md— Log cronologico del deploy reale (914 righe)
.
├── backend/
│ ├── FilmAPI/ # Backend ASP.NET Core Minimal API
│ │ ├── Data/ # DbContext, entità, migrazioni, seeder
│ │ ├── Endpoints/ # Gruppi di endpoint per dominio
│ │ ├── Services/ # Logica di business (~30 servizi)
│ │ ├── Models/ # DTO, request/response
│ │ ├── Program.cs # Bootstrap, middleware, rate limiter, auth
│ │ └── Dockerfile # Multi-stage build per container
│ └── scripts/FilmApiSeeder/ # Seeder standalone per Docker
├── frontend/
│ └── CineBase.Web/ # Frontend ASP.NET Core (host statico)
│ ├── wwwroot/ # HTML, JS, CSS, asset
│ │ ├── js/ # Moduli JavaScript (auth, api, navbar, pagine)
│ │ └── css/ # Tailwind CSS compilato
│ └── Program.cs # Host minimale, security headers
├── tests/
│ ├── backend/ # Test xUnit (639 test backend)
│ │ ├── Unit/ # Test di logica pura (5 classi)
│ │ └── Integration/ # Test pipeline completa (31 classi)
│ └── frontend/ # Test Playwright (~160 test frontend)
│ ├── playwright.config.cjs # Configurazione browser
│ ├── browser-audit.spec.cjs # Suite audit con mock API
│ └── docker-compose.smoke.spec.cjs # Smoke test contro stack reale
├── docs/
│ ├── dev_notes/ # Documentazione tecnica sintetica
│ ├── method/ # Metodologia di sviluppo
│ ├── project/ # Changelog, status, piani di lavoro, prompt
│ ├── tutorials/ # Tutorial passo-passo
│ └── user_manuals/ # Manuali utente per tutti i ruoli
├── infra/azure/aca/ # Definizioni YAML per Azure Container Apps
├── docker-compose.yml # Stack di sviluppo
├── docker-compose.e2e.yml # Override per test E2E
└── .env.docker.example # Variabili d'ambiente per Docker
Percorso consigliato per comprendere il progetto:
docs/method/processo-di-sviluppo.md— Il metodo: come è stato costruito, perché, con quali pratichedocs/project/changelog.md— La cronologia completa per vedere l'evoluzionedocs/project/dev_iteration/— I Piani di Lavoro originali di ogni iterazionedocs/project/prompt_log/— I prompt che hanno generato i Piani di Lavorodocs/dev_notes/architecture.md— L'architettura del prodottodocs/dev_notes/tests.md— La strategia di testdocs/user_manuals/— I manuali per gli utenti finali
This project is released under the Cinebase Source Available License (CSAL) v1.0. See LICENSE.txt for the full text.
- Educational use (schools, courses, training)
- Personal projects
- Academic research
- Study, modification, and experimentation
- Commercial use of any kind
- Selling the software or derivatives
- Offering it as a SaaS or hosted service
- Running a ticketing or booking business using this software
- Integrating it into commercial platforms
Commercial use is not permitted by default.
If you are interested in:
- deploying this software in a business context
- offering ticketing services
- integrating it into a commercial product
you must obtain a separate commercial license.
📬 Contact: github.com/malafronte
🌐 Demo: www.cinebase.it
This is a source-available license, not an OSI-approved open source license, because it restricts commercial usage.
CineBase è un progetto didattico. Non è un prodotto commerciale. Il suo valore risiede nel processo, nella documentazione e nella metodologia che dimostra.