Workout Tracker Application

A comprehensive workout plan manager built with .NET 10, Blazor WebAssembly, and SQLite that enables users to create, manage, and execute workout sessions with real-time tracking.

Project Structure

WorkoutTracker/
├── src/
│   ├── WorkoutTracker.Domain/           # Core domain entities and interfaces
│   │   ├── Entities/                    # Domain entities (Exercise, WorkoutPlan, etc.)
│   │   ├── Enums/                       # Domain enums (ExerciseType, DurationType)
│   │   └── Interfaces/                  # Repository interfaces
│   │
│   ├── WorkoutTracker.Contracts/        # Shared DTOs and request types
│   │   ├── Common/                      # Shared enums and types
│   │   ├── Exercises/                   # Exercise DTOs and requests
│   │   ├── WorkoutPlans/                # WorkoutPlan DTOs and requests
│   │   ├── WorkoutSessions/             # WorkoutSession DTOs and requests
│   │   ├── PlanExercises/               # PlanExercise DTOs and requests
│   │   └── SetRecords/                  # SetRecord DTOs and requests
│   │
│   ├── WorkoutTracker.Application/      # Application services layer
│   │   ├── Common/Mappings/             # Entity to DTO mapping extensions
│   │   ├── Exercises/                   # Exercise service and validators
│   │   ├── WorkoutPlans/                # WorkoutPlan service and validators
│   │   ├── WorkoutSessions/             # WorkoutSession service and validators
│   │   └── SetRecords/                  # SetRecord service and validators
│   │
│   ├── WorkoutTracker.Infrastructure/   # Infrastructure layer
│   │   ├── Data/                        # DbContext, configurations, seeder
│   │   ├── Repositories/                # Repository implementations
│   │   └── Migrations/                  # EF Core migrations
│   │
│   ├── WorkoutTracker.API/              # Backend REST API (.NET 10)
│   │   ├── Controllers/                 # API endpoints
│   │   └── Extensions/                  # ErrorOr result extensions
│   │
│   └── WorkoutTracker.Client/           # Frontend (Blazor WebAssembly)
│       ├── Pages/                       # Blazor pages/components
│       └── Services/                    # API communication services
│
├── tests/
│   └── WorkoutTracker.Tests/            # xUnit test project
│
└── WorkoutTracker.sln                   # Solution file

Architecture

The application follows Clean Architecture principles with clear separation of concerns:

┌─────────────────────────────────────────────────────────────────┐
│                     PRESENTATION LAYER                          │
│   WorkoutTracker.API        WorkoutTracker.Client               │
│   (Controllers)             (Blazor WASM)                       │
└─────────────────┬─────────────────────────┬─────────────────────┘
                  │                         │
┌─────────────────┴─────────────────────────┴─────────────────────┐
│                     INFRASTRUCTURE LAYER                         │
│   WorkoutTracker.Infrastructure                                  │
│   (EF Core DbContext, Repositories)                              │
└─────────────────────────────┬───────────────────────────────────┘
                              │
┌─────────────────────────────┴───────────────────────────────────┐
│                     APPLICATION LAYER                            │
│   WorkoutTracker.Application                                     │
│   (Services, Validators, Mappings)                               │
└─────────────────────────────┬───────────────────────────────────┘
                              │
┌─────────────────────────────┴───────────────────────────────────┐
│                        CORE LAYER                                │
│   WorkoutTracker.Domain          WorkoutTracker.Contracts        │
│   (Entities, Interfaces)         (DTOs, API Contracts)           │
└─────────────────────────────────────────────────────────────────┘

Key Architectural Patterns

• Domain-Driven Design (DDD): Rich domain entities with private setters and factory methods
• Repository Pattern: Abstracted data access through repository interfaces
• Unit of Work: Coordinated database transactions
• Result Pattern: ErrorOr for explicit error handling without exceptions
• FluentValidation: Request validation in the application layer

Features Implemented

Core Features

• Workout Plan Management: Create and view workout plans with multiple exercises
• Exercise Types: Support for time-based, repetition-based, and duration-based exercises
• Real-Time Set Tracking: Track weight, reps, execution time, and recovery time for each set
• Recovery Timer: Visual countdown timer with color-coded feedback (green → yellow → red)
• Data Persistence: SQLite database with Entity Framework Core
• Seeded Test Data: "Full Body Workout A" plan pre-loaded for testing

Technical Implementation

• .NET 10 backend API with RESTful endpoints
• Blazor WebAssembly for responsive web UI
• SQLite database for cross-platform local storage
• Entity Framework Core 10 ORM with migrations
• xUnit test framework with 136 passing tests
• Git version control with proper .gitignore

Getting Started

Prerequisites

• .NET 10 SDK
• Git

Running the Application

1. Start the Backend API

cd src/WorkoutTracker.API
dotnet run

The API will start on:

• HTTPS: https://localhost:7001
• HTTP: http://localhost:5000

The database will be automatically created and seeded with test data on first run.

2. Start the Blazor Client

In a new terminal:

cd src/WorkoutTracker.Client
dotnet run

The client will start on:

• HTTPS: https://localhost:7002
• HTTP: http://localhost:5001

API Endpoints

Workout Plans

• GET /api/WorkoutPlans - Get all workout plans
• GET /api/WorkoutPlans/{id} - Get specific workout plan
• POST /api/WorkoutPlans - Create new workout plan
• PUT /api/WorkoutPlans/{id} - Update workout plan
• DELETE /api/WorkoutPlans/{id} - Delete workout plan

Exercises

• GET /api/Exercises - Get all exercises
• GET /api/Exercises/{id} - Get specific exercise
• POST /api/Exercises - Create new exercise
• PUT /api/Exercises/{id} - Update exercise
• DELETE /api/Exercises/{id} - Delete exercise

Workout Sessions

• GET /api/WorkoutSessions - Get all sessions
• GET /api/WorkoutSessions/{id} - Get specific session
• POST /api/WorkoutSessions - Start new session
• PUT /api/WorkoutSessions/{id}/complete - Complete session
• DELETE /api/WorkoutSessions/{id} - Delete session

Set Records

• GET /api/SetRecords - Get all set records
• GET /api/SetRecords/{id} - Get specific set record
• GET /api/SetRecords/session/{sessionId} - Get sets for a session
• POST /api/SetRecords - Record a completed set
• DELETE /api/SetRecords/{id} - Delete a set record

Database Schema

WorkoutPlan

• Stores workout plan metadata (name, description, creation date)

Exercise

• Defines exercises with muscle groups, images, videos, and type

PlanExercise

• Junction table linking plans to exercises with target sets/reps/duration

WorkoutSession

• Tracks individual workout sessions

SetRecord

• Records each completed set with actual performance data

Seeded Test Data

The application includes a pre-configured "Full Body Workout A" plan with 10 exercises:

1. Treadmill (10 min warm-up)
2. Lunges (4 sets x 10 reps)
3. Leg Extension (4 sets x 10 reps)
4. Horizontal Press (3 sets x 8 reps)
5. One-Arm Dumbbell Row (3 sets x 15 reps)
6. Dumbbell Shoulder Press (3 sets x 12 reps)
7. Lat Machine (4 sets x 10 reps)
8. Chest Press (4 sets x 10 reps)
9. Plank (4 sets x 30 sec)
10. Treadmill Uphill (10 min cool-down)

User Interface

Home Page

• Displays all available workout plans as cards
• Shows exercise count and creation date
• "Start Workout" button to begin a session

Active Workout Page

• Current exercise details with muscle groups
• Set tracking form (weight, reps/duration, execution time)
• Recovery Timer with visual feedback:
  • Green: Within suggested recovery time
  • Yellow: 1-1.5x suggested time
  • Red: Over 1.5x suggested time
• Progress indicator showing remaining exercises
• "End Workout" button to complete session

Configuration

API Base URL

The client is configured to connect to the API at https://localhost:7001. To change this, edit:

File: src/WorkoutTracker.Client/wwwroot/appsettings.json

{
  "ApiBaseUrl": "https://localhost:7001"
}

Database Connection

The API uses SQLite with a local database file. To change the connection string, edit:

File: src/WorkoutTracker.API/appsettings.json

{
  "ConnectionStrings": {
    "DefaultConnection": "Data Source=workouttracker.db"
  }
}

Testing

The project includes comprehensive tests with 136 passing tests covering:

• Controller integration tests
• Client service tests
• Database seeding tests
• Domain entity tests

# Run all tests
dotnet test

# Run with verbose output
dotnet test --verbosity normal

Build & Run Commands

# Build entire solution
dotnet build WorkoutTracker.sln

# Build API only
dotnet build src/WorkoutTracker.API/WorkoutTracker.API.csproj

# Build Client only
dotnet build src/WorkoutTracker.Client/WorkoutTracker.Client.csproj

# Run tests
dotnet test

# Create new migration
cd src/WorkoutTracker.API
dotnet ef migrations add MigrationName

# Update database
dotnet ef database update

Future Enhancements

The database schema and architecture support these planned features:

• Workout history and calendar view
• Progress tracking with charts
• Personal record (PR) tracking
• Custom exercise creation
• Workout plan templates
• Body measurements tracking
• Mobile deployment (MAUI conversion)

Architecture Notes

• Clean Architecture: Strict dependency rules between layers
• CORS: Configured to allow Blazor client origins
• Database Seeding: Automatic on application start
• Future Mobile Support: Architecture designed for MAUI conversion
• RESTful API: Clean separation between frontend and backend
• ErrorOr Result Pattern: Explicit error handling without exceptions

License

This project was created as a demonstration application.

Developer Notes

• Created with .NET 10.0.101
• Blazor WebAssembly for web-first development
• SQLite for simple, portable data storage
• Architecture supports future Android deployment via MAUI