Personal Course Tracker

A comprehensive full-stack application for tracking personal learning progress, managing courses, setting learning goals, and monitoring educational achievements.

🚀 Features

Course Management

• Add & Track Courses: Support for various course types (Videos, Books, Articles, Workshops, Certifications, Tutorials, Podcasts, Documentation)
• Progress Tracking: Monitor completion percentage and time spent
• Course Status Management: Track courses as Not Started, In Progress, Paused, Completed, or Abandoned
• Priority System: Organize courses by priority levels (Low, Medium, High, Urgent)
• Difficulty Levels: Categorize courses by difficulty (Beginner, Intermediate, Advanced, Expert)

Learning Goals

• Goal Setting: Create and manage learning objectives
• Progress Monitoring: Track goal progress with visual indicators
• Deadline Management: Set and monitor target completion dates
• Category Organization: Organize goals by categories

Categories & Organization

• Category Management: Create custom categories with colors and icons
• Advanced Filtering: Filter courses by status, type, priority, and search terms
• Sorting Options: Sort courses by various criteria

Course Interactions

• Rating System: Rate completed courses and write reviews
• Notes & Reviews: Add personal notes and detailed reviews
• Time Tracking: Log study time and monitor learning progress

🏗️ Architecture

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

Backend (.NET 9)

• API Layer: RESTful API with controllers, exception handling, and health checks
• Application Layer: Business logic, CQRS with MediatR, DTOs, and validation
• Domain Layer: Core entities, value objects, enums, and domain events
• Infrastructure Layer: Data access, Entity Framework Core, SQL Server integration

Frontend (Angular 18)

• Component-based Architecture: Modular and reusable UI components
• Services: HTTP client services for API communication
• Reactive Programming: RxJS for handling asynchronous operations
• Responsive Design: Tailwind CSS for modern, mobile-first UI

Database

• SQL Server: Robust relational database with Entity Framework Core
• Migrations: Database versioning and schema management
• Health Checks: Database connectivity monitoring

🛠️ Technology Stack

Backend

• .NET 9: Latest .NET framework for high-performance APIs
• Entity Framework Core: Object-relational mapping and database access
• MediatR: CQRS and mediator pattern implementation
• FluentValidation: Input validation and business rule enforcement
• Swagger/OpenAPI: API documentation and testing interface
• SQL Server: Primary database system

Frontend

• Angular 18: Modern web framework with TypeScript
• Tailwind CSS: Utility-first CSS framework for styling
• RxJS: Reactive programming library for handling async operations
• Angular CLI: Development and build tooling

DevOps & Infrastructure

• Docker: Containerization for all services
• Docker Compose: Multi-container orchestration
• Health Checks: Service monitoring and reliability
• CORS Configuration: Secure cross-origin resource sharing

📋 Prerequisites

Before running this project, ensure you have the following installed:

• Docker Desktop (latest version)
• Git for version control
• .NET 9 SDK (for local development)
• Node.js 18+ and npm (for local frontend development)
• SQL Server (optional, for local development without Docker)

🚀 Quick Start

Option 1: Docker Compose (Recommended)

1. Clone the repository:

   git clone https://github.com/othmanTeffahi99/PersonalCourseTracker.git
   cd PersonalCourseTracker

2. Start all services:

   docker-compose up -d

3. Wait for services to be ready (approximately 2-3 minutes for first startup)

4. Access the application:

   • Frontend: http://localhost:4200
   • API Documentation: http://localhost:5000/swagger
   • Health Check: http://localhost:5000/health

Option 2: Local Development

Prerequisites for Local Development

• .NET 8 SDK
• Node.js 18+ and npm
• SQL Server (or use Docker for database only)

Database Only (Recommended for Development)

# Start only the database
docker-compose -f compose.dev.yaml up -d

Backend Setup

1. Navigate to API project:

   cd PersonalCourseTracker.Api

2. Restore dependencies:

   dotnet restore

3. Update database connection in appsettings.Development.json (if not using Docker database)

4. Run database migrations:

   dotnet ef database update

5. Start the API:

   dotnet run

   API will be available at: http://localhost:5198

Frontend Setup

1. Open a new terminal and navigate to Angular project:

   cd PersonalCourseTracker.WebApp

2. Install dependencies:

   npm install

3. Start development server:

   npm start

   Frontend will be available at: http://localhost:4200

Option 3: Mixed Development

You can also run some services in Docker and others locally:

# Database only
docker-compose -f compose.dev.yaml up -d

# Or database + API
docker-compose up -d sqlserver api

# Then run frontend locally
cd PersonalCourseTracker.WebApp
npm start

🔧 Configuration

Environment Variables

API Configuration (appsettings.json)

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost;Database=PersonalCourseTracker;Trusted_Connection=true;TrustServerCertificate=true;"
  },
  "DatabaseProvider": "SqlServer"
}

Frontend Configuration

• Development: src/environments/environment.ts
• Production: src/environments/environment.prod.ts

Docker Configuration

All services are configured via Docker Compose with:

• SQL Server: Port 1433 with automatic initialization
• API: Port 5000 with health checks
• Frontend: Port 4200 with nginx serving

📊 API Endpoints

Courses

• GET /api/courses - Get all courses with filtering
• GET /api/courses/{id} - Get specific course details
• POST /api/courses - Create new course
• PUT /api/courses/{id} - Update course
• DELETE /api/courses/{id} - Delete course
• POST /api/courses/{id}/progress - Update progress
• POST /api/courses/{id}/start - Start course
• POST /api/courses/{id}/pause - Pause course
• POST /api/courses/{id}/resume - Resume course
• POST /api/courses/{id}/complete - Complete course
• POST /api/courses/{id}/abandon - Abandon course
• POST /api/courses/{id}/rate - Rate course

Categories

• GET /api/categories - Get all categories
• POST /api/categories - Create new category

Learning Goals

• GET /api/goals - Get all learning goals
• POST /api/goals - Create new goal
• PUT /api/goals/{id}/progress - Update goal progress

🧪 Testing

Backend Tests

# Run all tests
dotnet test

# Run specific test project
dotnet test PersonalCourseTracker.Application.Test
dotnet test PersonalCourseTracker.Domain.Test

📱 Usage Guide

Adding a New Course

1. Navigate to the course management section
2. Click "Add New Course"
3. Fill in course details (title, type, description, etc.)
4. Set priority and difficulty level
5. Assign to a category (optional)
6. Save the course

Tracking Progress

1. Select a course from your list
2. Click "Update Progress"
3. Enter completion percentage and time spent
4. Add notes about your learning session
5. Save progress

Setting Learning Goals

1. Go to the Goals section
2. Click "Create New Goal"
3. Define your learning objective
4. Set target completion date
5. Assign to a category
6. Track progress over time

🔍 Monitoring & Health Checks

The application includes comprehensive health checks:

• Database connectivity: Ensures SQL Server is accessible
• API health: Monitors API service status
• Frontend availability: Checks Angular application status

Access health check endpoint: GET /health

🐛 Troubleshooting

Common Issues

Docker containers not starting:

# Check container logs
docker-compose logs

# Restart specific service
docker-compose restart api

Database connection issues:

# Check SQL Server container
docker-compose logs sqlserver

# Restart database
docker-compose restart sqlserver

Frontend build issues:

# Clear npm cache
npm cache clean --force

# Reinstall dependencies
rm -rf node_modules package-lock.json
npm install

Database Issues

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