Entwicklungsumgebung für Gongomat einrichten

Diese Anleitung beschreibt Schritt für Schritt, wie Sie eine vollständige Entwicklungsumgebung für das Gongomat-Projekt einrichten.

Grundsätzlich wird empfohlen, Visual Studio 2022 zu verwenden, da es die beste Integration für .NET-Projekte bietet. Alternativ können Sie auch Visual Studio Code nutzen, wenn Sie eine plattformübergreifende Lösung bevorzugen. Das System sollte sowohl in einem Windows wie auch einem Unix Backend laufen.

Entwickelt kann das Projekt auf Windows, macOS und Linux werden. Einige Schritte, insbesondere die Installation von SQL Server, unterscheiden sich jedoch je nach Betriebssystem.

Die Entwicklung in einer Docker-Umgebung ist möglich, wird aber in dieser Anleitung nur spartanisch behandelt. Diese Form der Entwicklung ist auch nicht final getestet worden.

Inhaltsverzeichnis

• Systemvoraussetzungen
• Software installieren
• Projekt einrichten
• Datenbank konfigurieren
• Projekt starten
• Optionale Entwicklungstools
• Erste Schritte nach der Installation
• Fehlerbehebung

Systemvoraussetzungen

Minimale Anforderungen

• Betriebssystem: Windows 10/11, macOS, oder Linux
• RAM: Mindestens 8 GB (16 GB empfohlen)
• Festplattenspeicher: Mindestens 10 GB frei
• Prozessor: Dual-Core oder besser

Software installieren

1. .NET 8 SDK installieren

Das Projekt verwendet .NET 8, daher muss das entsprechende SDK installiert werden.

1. Besuchen Sie: https://dotnet.microsoft.com/download/dotnet/8.0
2. Laden Sie das .NET 8 SDK für Ihr Betriebssystem herunter
3. Führen Sie die Installation aus
4. Überprüfen Sie die Installation im Terminal/PowerShell:

dotnet --version

Die Ausgabe sollte eine Version 8.x.x anzeigen.

2. IDE installieren

Option A: Visual Studio 2022 (empfohlen für Windows)

1. Laden Sie Visual Studio 2022 herunter: https://visualstudio.microsoft.com/downloads/
2. Installieren Sie die Community Edition (kostenlos) oder höher
3. Wählen Sie bei der Installation folgende Workloads aus:
   • ✅ ASP.NET and web development
   • ✅ .NET desktop development
   • ✅ Data storage and processing
   • ✅ Azure development (optional)

Hinweis: Visual Studio 2025/2026 ist aktuell noch nicht vollständig kompatibel - nutzen Sie Visual Studio 2022.

Option B: Visual Studio Code (plattformübergreifend)

1. Laden Sie VS Code herunter: https://code.visualstudio.com/
2. Installieren Sie folgende Extensions:
   • C# Dev Kit (Microsoft)
   • C# (Microsoft)
   • .NET Install Tool (Microsoft)
   • SQL Server (mssql) (Microsoft)
   • NuGet Package Manager
   • GitLens (optional)
   • Prettier (empfohlen)

WICHTIG: Konfigurieren sie die IDE so dass sie neue Dateien mit UTF8 und LF als Zeichenende erstellt.
Hinweis: VS Code akzeptiert .editorconfig, trotz gegenteiliger Behauptungen, nicht wirklich! Siehe dazu auch UTF8 Encoding

3. SQL Server installieren

Das Projekt verwendet SQL Server als Datenbank.

Windows

1. Laden Sie SQL Server 2022 Express herunter: https://www.microsoft.com/de-de/sql-server/sql-server-downloads
2. Installieren Sie die Express-Edition (kostenlos)
3. Installieren Sie SQL Server Management Studio (SSMS) (optional, aber empfohlen): https://docs.microsoft.com/de-de/sql/ssms/download-sql-server-management-studio-ssms

macOS/Linux

1. Installieren Sie SQL Server über Docker:

docker pull mcr.microsoft.com/mssql/server:2022-latest
docker run -e "ACCEPT_EULA=Y" -e "SA_PASSWORD=YourStrong@Passw0rd" \
   -p 1433:1433 --name sqlserver2022 \
   -d mcr.microsoft.com/mssql/server:2022-latest

2. Oder verwenden Sie Azure Data Studio: https://docs.microsoft.com/de-de/sql/azure-data-studio/download

4. Git installieren

1. Laden Sie Git herunter: https://git-scm.com/downloads
2. Installieren Sie Git mit den Standardeinstellungen
3. Überprüfen Sie die Installation:

git --version

Projekt einrichten

1. Repository klonen

Öffnen Sie ein Terminal/PowerShell und navigieren Sie zum gewünschten Verzeichnis:

git clone -b GomgomatV2 https://github.com/internauten/Gongomat240206.git
cd Gongomat240206

2. NuGet-Pakete wiederherstellen

Stellen Sie alle benötigten NuGet-Pakete wieder her:

dotnet restore

Oder in Visual Studio:

• Rechtsklick auf die Solution → Restore NuGet Packages

3. Projektstruktur verstehen

Gongomat240206/
├── Gongomat/                 # Hauptprojekt (Blazor Server)
│   ├── Components/           # Blazor-Komponenten
│   │   ├── Pages/            # Seiten (Routing)
│   │   ├── Api/              # Webservices (json)
│   │   └── Layout/           # Layout-Komponenten
│   ├── Data/                 # Entity Framework DbContext & Models
│   ├── Hubs/                 # SignalR Hubs
│   ├── Migrations/           # EF Core Migrationen
│   ├── wwwroot/              # Statische Dateien (CSS, JS, Sounds)
│   ├── appsettings.json      # Konfiguration (produktiv)
│   ├── appsettings.Development.json  # Konfiguration (lokal)
│   └── Program.cs            # Anwendungseinstieg
└── README.md

Datenbank konfigurieren

1. Connection Strings einrichten

Das Projekt verwendet zwei Datenbanken:

• DefaultConnection: Für ASP.NET Identity (Benutzer, Rollen)
• GongomatConnection: Für Anwendungsdaten (Gongs, Patterns, etc.)

So kann für die Benutzeridentifikation und die Anwendungsdaten jeweils eine separate Datenbank verwendet werden. Momentan werden beide Entitäten in einer DB geführt.

Entwicklungsumgebung

Hinweis: Legen sie die Connection string, wenn möglich, immer in den user-secrets ab. So besteht keine Gefahr dass diese im Github mit Passwort erscheinen.

Wie unten je nach Art der DB anpasssen:

cd Gongomat
dotnet user-secrets init
dotnet user-secrets set "ConnectionStrings:DefaultConnection" "Server=YOURSERVERNAME;Database=GongomatIdentity;Trusted_Connection=True;MultipleActiveResultSets=true"
dotnet user-secrets set "ConnectionStrings:GongomatConnection" "Server=YOURSERVERNAME;Database=GongomatData;Trusted_Connection=True;MultipleActiveResultSets=true"

Bearbeiten Sie Gongomat/appsettings.Development.json:

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=GongomatIdentity;Trusted_Connection=True;MultipleActiveResultSets=true",
    "GongomatConnection": "Server=(localdb)\\mssqllocaldb;Database=GongomatData;Trusted_Connection=True;MultipleActiveResultSets=true"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  }
}

Für SQL Server Express (statt LocalDB):

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost\\SQLEXPRESS;Database=GongomatIdentity;Trusted_Connection=True;TrustServerCertificate=True;MultipleActiveResultSets=true",
    "GongomatConnection": "Server=localhost\\SQLEXPRESS;Database=GongomatData;Trusted_Connection=True;TrustServerCertificate=True;MultipleActiveResultSets=true"
  }
}

Für Docker SQL Server (Linux/macOS):

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost,1433;Database=GongomatIdentity;User Id=sa;Password=YourStrong@Passw0rd;TrustServerCertificate=True;MultipleActiveResultSets=true",
    "GongomatConnection": "Server=localhost,1433;Database=GongomatData;User Id=sa;Password=YourStrong@Passw0rd;TrustServerCertificate=True;MultipleActiveResultSets=true"
  }
}

2. Entity Framework Core Tools installieren

Falls noch nicht installiert:

dotnet tool install --global dotnet-ef

Oder aktualisieren:

dotnet tool update --global dotnet-ef

Überprüfen:

dotnet ef

Möglicherweise braucht es noch folgenden Befehl:

cd Gongomat
dotnet tool restore

Tritt ein Fehler auf bei der Installation von dotnet-ef empfiehlt sich folgendes Vorgehen:

dotnet tool uninstall --global dotnet-ef
dotnet nuget locals all --clear
dotnet tool install --global dotnet-ef --version 8.0.14
dotnet tool restore

3. Datenbank-Migrationen ausführen

Hinweis: Dammit die Migration auch getestet wird sollte immer eine Kopie der produktiven DB für das Testsystem verwendet werden.

WICHTIG: Beim ersten Setup müssen Sie zuerst die Migrationen erstellen, bevor Sie sie ausführen können!

Das Projekt verwendet zwei DbContexts, daher müssen die Migrationen für beide ausgeführt werden: (beide werden momentan in einer DB abgelegt, können aber auch getrennt werden)

ApplicationDbContext (Identity)

cd Gongomat
dotnet ef database update --context ApplicationDbContext

GongomatContext (Anwendungsdaten)

dotnet ef database update --context GongomatContext

In Visual Studio über die Package Manager Console:

Update-Database -Context ApplicationDbContext
Update-Database -Context GongomatContext

Hinweis: Die bestehenden Migrationen im Ordner "Migrations/" gehören zum GongomatContext. Die Identity-Migrationen sollten in einem separaten Ordner "Migrations/Identity/" gespeichert werden.

4. Neue Migrationen erstellen (bei Bedarf)

Wenn Sie das Datenbankschema ändern:

# ApplicationDbContext (Identity-Tabellen)
dotnet ef migrations add MigrationName --context ApplicationDbContext --output-dir Migrations/Identity

# GongomatContext (Anwendungsdaten)
dotnet ef migrations add MigrationName --context GongomatContext --output-dir Migrations/Gongomat

In Visual Studio Package Manager Console:

# ApplicationDbContext
Add-Migration MigrationName -Context ApplicationDbContext -OutputDir Migrations\Identity

# GongomatContext
Add-Migration MigrationName -Context GongomatContext -OutputDir Migrations\Gongomat

Migration entfernen (falls Fehler):

dotnet ef migrations remove --context ApplicationDbContext
# oder
dotnet ef migrations remove --context GongomatContext

Tipp: Verwenden Sie immer den Parameter --output-dir bzw. -OutputDir, um die Migrationen der beiden Contexts zu trennen.

Projekt starten

Mit Visual Studio 2022

1. Öffnen Sie die Solution-Datei: Gongomat240206.sln
2. Warten Sie, bis alle NuGet-Pakete wiederhergestellt sind
3. Setzen Sie Gongomat als Startprojekt (Rechtsklick → Set as Startup Project)
4. Drücken Sie F5 oder klicken Sie auf Start
5. Die Anwendung öffnet sich im Browser unter:
   • HTTPS: https://localhost:7125
   • HTTP: http://localhost:5226

Mit Visual Studio Code

1. Öffnen Sie den Projektordner in VS Code
2. Drücken Sie F5 oder gehen Sie zu Run and Debug
3. Wählen Sie .NET Core Launch (web)
4. Die Anwendung startet

Mit der Kommandozeile

cd Gongomat
dotnet run

Oder für Hot Reload (automatisches Neuladen bei Code-Änderungen):

dotnet watch run

Optionale Entwicklungstools

SQL Server Management Studio (SSMS)

Für die Verwaltung der SQL Server-Datenbanken:

• Download: https://docs.microsoft.com/de-de/sql/ssms/download-sql-server-management-studio-ssms
• Nützlich für Datenbankabfragen, Schema-Ansichten und Debugging

Azure Data Studio

Plattformübergreifende Alternative zu SSMS:

• Download: https://docs.microsoft.com/de-de/sql/azure-data-studio/download
• Funktioniert auf Windows, macOS und Linux

Postman oder Thunder Client

Für das Testen von API-Endpunkten:

• Postman: https://www.postman.com/downloads/
• Thunder Client (VS Code Extension): Leichtgewichtige Alternative

GitHub Desktop (optional)

Für einfachere Git-Verwaltung:

• Download: https://desktop.github.com/

Erste Schritte nach der Installation

Dies kann entfallen wenn auf einer Kopie der preoduktiven Daten gearbeitet wird.

-- Beispiel: Admin Rolle einfügen
INSERT INTO AspNetRoles (Id, Name, NormalizedName, ConcurrencyStamp)
VALUES (NEWID(), 'Admin', 'ADMIN', NEWID());
-- Beispiel: Benutzer zur Admin-Rolle hinzufügen
INSERT INTO AspNetUserRoles (UserId, RoleId)
SELECT u.Id, r.Id
FROM AspNetUsers u, AspNetRoles r
WHERE u.Email = 'your@email.com' AND r.Name = 'Admin';

INSERT INTO tenant (name)
VALUES ('DEKMEDUSZ');

dotnet ef database drop --context ApplicationDbContext --force
dotnet ef database drop --context GongomatContext --force
dotnet ef database update --context ApplicationDbContext
dotnet ef database update --context GongomatContext

cd Gongomat
dotnet ef migrations add InitialIdentity --context ApplicationDbContext --output-dir Migrations/Identity
dotnet ef database update --context ApplicationDbContext

"applicationUrl": "https://localhost:7126;http://localhost:5227"

 git config --global user.email "ihre@emailadresse.ch"
 git config --global user.name "ihrgitbenutzername"

sed -i 's/\r$//' .devcontainer/mssql/postCreateCommand.sh
sed -i 's/\r$//' .devcontainer/mssql/installSQLtools.sh

ps aux | grep -E "dotnet.*Gongomat" | grep -v grep

vscode 15298 0.3 0.7 274666112 119268 ? Sl 13:54 0:00 /usr/bin/dotnet /workspaces/Gongomat240206/Gongomat/bin/Debug/net8.0/Gongomat.dll

kill -9 15298