Skip to content

render93/deveats

BranchesTags

Repository files navigation

DevEats - Piattaforma di Recensioni Ristoranti

DevEats è una piattaforma moderna per recensire ristoranti, sviluppata con .NET 8, Blazor Server, Entity Framework Core e SQL Server. Il progetto è destinato al deployment su Azure (Azure SQL Database + Azure App Service).

Caratteristiche

  • Blazor Server: Interfaccia utente reattiva e moderna
  • Entity Framework Core: ORM per la gestione del database con migrazioni automatiche
  • SQL Server / Azure SQL Database: Database relazionale scalabile
  • Bootstrap 5: Design responsive e accattivante
  • CI/CD: GitHub Actions per deployment automatico su Azure
  • Test Unitari: Copertura completa con NUnit
  • Seeding Automatico: Popolamento dati di esempio all'avvio

Struttura del Progetto

Il progetto segue un'architettura a 3 livelli:

DevEats/
├── src/
│   ├── DevEats.Core/              # Modelli di dominio e interfacce
│   │   ├── Models/                # Restaurant, Review
│   │   └── Interfaces/            # IRestaurantService, IReviewService
│   ├── DevEats.Infrastructure/    # Implementazione EF Core
│   │   ├── Data/                  # DevEatsDbContext, DataSeeder
│   │   ├── Services/              # RestaurantService, ReviewService
│   │   └── Migrations/            # Migrazioni database EF Core
│   └── DevEats.Web/               # Applicazione Blazor Server
│       └── Pages/                 # Index.razor, RestaurantDetails.razor
├── tests/
│   └── DevEats.Tests/             # Test unitari NUnit
└── scripts/
    ├── start-dev.sh/.ps1          # Script di avvio sviluppo
    └── stop-dev.sh/.ps1           # Script di arresto

Prerequisiti

Setup Locale con Docker (Consigliato)

Metodo Rapido - Con Script Automatico

Su macOS/Linux:

# 1. Clonare il repository
git clone https://github.com/your-username/deveats.git
cd deveats

# 2. Avviare tutto (Docker + Applicazione)
./scripts/start-dev.sh

Su Windows (PowerShell):

# 1. Clonare il repository
git clone https://github.com/your-username/deveats.git
cd deveats

# 2. Avviare tutto (Docker + Applicazione)
.\scripts\start-dev.ps1

Lo script automaticamente:

  • ✅ Avvia SQL Server 2022 in Docker
  • ✅ Attende che il database sia pronto
  • ✅ Avvia l'applicazione Blazor
  • ✅ Applica automaticamente le migrazioni EF Core
  • ✅ Popola i dati di esempio tramite DataSeeder

L'applicazione sarà disponibile su: https://localhost:5001

Fermare l'ambiente di sviluppo

macOS/Linux:

./scripts/stop-dev.sh

Windows:

.\scripts\stop-dev.ps1

Metodo Manuale

Se preferisci maggiore controllo, puoi eseguire i passaggi manualmente:

1. Avviare SQL Server con Docker

# Avviare SQL Server
docker-compose up -d

# Verificare che sia in esecuzione
docker ps

2. Ripristinare i pacchetti

dotnet restore

3. Build della soluzione

dotnet build

4. Avviare l'applicazione

cd src/DevEats.Web
dotnet run

L'applicazione sarà disponibile su https://localhost:5001

Le migrazioni e il seeding dei dati avvengono automaticamente all'avvio dell'applicazione.

Informazioni Database Docker

  • Server: localhost,1433
  • Database: deveats_dev (creato automaticamente)
  • Username: sa
  • Password: DevEats2024!
  • Connection String: Configurata in appsettings.Development.json

Comandi Utili

Docker

# Visualizzare i log di SQL Server
docker logs deveats-sqlserver

# Rimuovere tutto inclusi i dati (reset completo)
docker-compose down -v

# Riavviare SQL Server
docker-compose restart

# Fermare i container
docker-compose down

Build e Test

# Build dell'intera soluzione
dotnet build

# Build di un progetto specifico
dotnet build src/DevEats.Core/DevEats.Core.csproj
dotnet build src/DevEats.Infrastructure/DevEats.Infrastructure.csproj
dotnet build src/DevEats.Web/DevEats.Web.csproj

# Eseguire tutti i test
dotnet test

# Eseguire test di un progetto specifico
dotnet test tests/DevEats.Tests/DevEats.Tests.csproj

# Eseguire un test specifico
dotnet test --filter "FullyQualifiedName~DataSeederTests"

Operazioni Database

# Aggiungere una nuova migrazione
cd src/DevEats.Infrastructure
dotnet ef migrations add NomeMigrazione --startup-project ../DevEats.Web

# Aggiornare il database manualmente (normalmente avviene automaticamente all'avvio)
dotnet ef database update --startup-project ../DevEats.Web

# Rimuovere l'ultima migrazione
dotnet ef migrations remove --startup-project ../DevEats.Web

# Reset completo del database
docker-compose down -v
docker-compose up -d

Architettura

DevEats.Core

Layer di dominio con modelli (Restaurant, Review) e interfacce dei servizi (IRestaurantService, IReviewService).

DevEats.Infrastructure

Implementazione dell'infrastruttura con:

  • DevEatsDbContext: Context di Entity Framework Core
  • Services: Implementazioni concrete dei servizi
  • DataSeeder: Popola il database con dati di esempio all'avvio
  • Migrations: Migrazioni EF Core per versioning del database

DevEats.Web

Applicazione Blazor Server con componenti Razor, configurazione Dependency Injection, middleware, auto-migrazione e seeding.

DevEats.Tests

Test unitari con NUnit per la logica di seeding, operazioni sulle recensioni e operazioni sui ristoranti. I test utilizzano provider database in-memory per l'isolamento.

Funzionalità

  • Home Page: Lista di tutti i ristoranti con rating medio
  • Dettagli Ristorante: Informazioni dettagliate e visualizzazione recensioni
  • Aggiungi Recensione: Form per inviare nuove recensioni con rating
  • Rating Automatico: Calcolo automatico della media dei voti
  • Gestione Relazioni: Le recensioni sono collegate ai ristoranti con cascade delete

Setup Azure e CI/CD

Pipeline GitHub Actions

Il progetto include due workflow GitHub Actions:

  • deploy-test.yml: Deploy automatico all'ambiente di test
  • deploy-prod.yml: Deploy automatico all'ambiente di produzione

I workflow eseguono:

  1. Build con .NET 8
  2. Esecuzione dei test
  3. Publish su Azure Web App (richiede AZURE_WEBAPP_PUBLISH_PROFILE secret)

1. Creare Azure SQL Database

# Login ad Azure
az login

# Creare un resource group
az group create --name DevEatsRG --location westeurope

# Creare SQL Server
az sql server create \
  --name deveats-sql-server \
  --resource-group DevEatsRG \
  --location westeurope \
  --admin-user sqladmin \
  --admin-password <YourStrongPassword>

# Configurare firewall per permettere servizi Azure
az sql server firewall-rule create \
  --resource-group DevEatsRG \
  --server deveats-sql-server \
  --name AllowAzureServices \
  --start-ip-address 0.0.0.0 \
  --end-ip-address 0.0.0.0

# Creare database
az sql db create \
  --resource-group DevEatsRG \
  --server deveats-sql-server \
  --name DevEatsDB \
  --service-objective S0

2. Creare Azure App Service

# Creare App Service Plan
az appservice plan create \
  --name DevEatsPlan \
  --resource-group DevEatsRG \
  --sku B1 \
  --is-linux

# Creare Web App
az webapp create \
  --resource-group DevEatsRG \
  --plan DevEatsPlan \
  --name DevEats-WebApp \
  --runtime "DOTNET|8.0"

3. Configurare Connection String nell'App Service

# Configurare la connection string nell'App Service
az webapp config connection-string set \
  --resource-group DevEatsRG \
  --name DevEats-WebApp \
  --settings DefaultConnection="Server=tcp:deveats-sql-server.database.windows.net,1433;Initial Catalog=DevEatsDB;User ID=sqladmin;Password=<YourPassword>;Encrypt=True;TrustServerCertificate=False;Connection Timeout=30;" \
  --connection-string-type SQLAzure

4. Setup CI/CD con GitHub Actions

  1. Ottenere il Publish Profile:

    az webapp deployment list-publishing-profiles \
  --resource-group DevEatsRG \
  --name DevEats-WebApp \
  --xml

  2. Aggiungere Secret in GitHub:

    • Vai su GitHub Repository → Settings → Secrets and variables → Actions
    • Crea un nuovo secret chiamato AZURE_WEBAPP_PUBLISH_PROFILE
    • Incolla il contenuto XML del publish profile

  3. Push sul branch main:

    git add .
git commit -m "Deploy to Azure"
git push origin main

GitHub Actions eseguirà automaticamente build, test e deploy su Azure!

Dettagli Architetturali

Inizializzazione Database all'Avvio

L'applicazione applica automaticamente le migrazioni EF Core e popola i dati di esempio all'avvio. Il DataSeeder verifica se i dati esistono già prima di inserirli.

Pattern Service Layer

I servizi sono iniettati tramite Dependency Injection e implementano le interfacce definite in DevEats.Core. Le recensioni sono collegate ai ristoranti tramite foreign key con cascade delete.

Gestione Connection String

  • Development: Usa Docker SQL Server su localhost,1433 con database deveats_dev
  • Production: Configurato per Azure SQL Database tramite secret AZURE_WEBAPP_PUBLISH_PROFILE

Tecnologie Utilizzate

  • .NET 8: Framework applicativo
  • Blazor Server: UI framework con SignalR
  • Entity Framework Core: ORM con Code-First approach
  • SQL Server 2022 / Azure SQL: Database relazionale
  • Bootstrap 5: Framework CSS
  • NUnit: Framework di testing
  • GitHub Actions: CI/CD pipeline
  • Docker: Containerizzazione per ambiente di sviluppo

Workflow di Sviluppo

IMPORTANTE: Dopo aver apportato modifiche al codice, è necessario:

  1. Eseguire il build dei progetti modificati per verificare la compilazione
  2. Eseguire la suite di test per assicurarsi che nulla si sia rotto
# Build della soluzione
dotnet build

# Eseguire i test
dotnet test

Non saltare questi passaggi - rilevano problemi in anticipo e garantiscono la qualità del codice.

Estensioni Future

  • Autenticazione utenti con Azure AD B2C
  • Upload immagini ristoranti con Azure Blob Storage
  • Ricerca e filtri avanzati
  • Integrazione con Azure OpenAI per analisi sentiment recensioni
  • Notifiche in tempo reale con SignalR
  • Sistema di moderazione recensioni
  • API REST per applicazioni mobile

Contribuire

Le pull request sono benvenute! Per modifiche importanti, apri prima una issue per discutere cosa vorresti cambiare.

Licenza

MIT

Contatti

Per domande o supporto, apri una issue su GitHub.

Link Utili

About

No description, website, or topics provided.

Resources

Readme
Activity

Stars

1 star

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

 
 
 

Contributors

Languages