DEV Community: Farrukh Rehman

🧱 Lesson 13B: Centralized Error Handling & Validation (Frontend)

Farrukh Rehman — Mon, 16 Feb 2026 05:47:43 +0000

Series: From Code to Cloud: Building a Production-Ready .NET Application
By: Farrukh Rehman - Senior .NET Full Stack Developer / Team Lead
LinkedIn: https://linkedin.com/in/farrukh-rehman
GitHub: https://github.com/farrukh1212cs

Source Code Backend : https://github.com/farrukh1212cs/ECommerce-Backend.git

Source Code Frontend : https://github.com/farrukh1212cs/ECommerce-Frontend.git

🎯 Introduction
In the previous lesson (13A), we standardized the backend error responses. Now, in Lesson 13B, we will implement the Frontend counterpart using Angular Interceptors.

Instead of handling .subscribe({ error: ... }) in every single component or service, we will use a Global HTTP Interceptor. This interceptor will catch all error responses from the API, parse the standardized JSON, and display a user-friendly notification (using PrimeNG Toasts).

Step 1: Define the Error Response Interface

We need a TypeScript interface that matches the C# ErrorResponse class we created in the backend. This ensures type safety when parsing errors.

File: src/app/core/interceptors/error.interceptor.ts

export interface ErrorResponse {
    statusCode: number;
    message: string;
    details?: any;
}

Step 2: Implement the Error Interceptor

The interceptor sits in the HTTP pipeline. It checks if an error occurs, parses the message from the backend, and uses MessageService to show a toast.

File: src/app/core/interceptors/error.interceptor.ts

import { HttpErrorResponse, HttpInterceptorFn } from '@angular/common/http';
import { inject } from '@angular/core';
import { MessageService } from 'primeng/api';
import { catchError, throwError } from 'rxjs';
export const errorInterceptor: HttpInterceptorFn = (req, next) => {
    const messageService = inject(MessageService);
    return next(req).pipe(
        catchError((error: HttpErrorResponse) => {
            let errorMessage = 'An unexpected error occurred';
            let summary = 'Error';

            // 1. Handle Network Errors (Server offline / No internet)
            if (error.status === 0) {
                errorMessage = 'Network error. Please check your connection.';
                summary = 'Network Error';
            }
            // 2. Handle Backend Standardized Errors
            else if (error.error && typeof error.error === 'object' && 'message' in error.error) {
                const backendError = error.error as ErrorResponse;
                errorMessage = backendError.message || errorMessage;

                // Optional: Log validation details if present
                if (backendError.statusCode === 400 && backendError.details) {
                     console.error('Validation Details:', backendError.details);
                }
            } 
            // 3. Fallback for specific status codes
            else if (error.status === 404) {
                errorMessage = 'Resource not found';
            } else if (error.status === 401) {
                errorMessage = 'Unauthorized access';
                summary = 'Unauthorized';
            } else if (error.status === 403) {
                errorMessage = 'Forbidden access';
                summary = 'Forbidden';
            } else if (error.status === 500) {
                errorMessage = 'Internal Server Error';
                summary = 'Server Error';
            }
            // 4. Display Toast Notification
            messageService.add({ 
                severity: 'error', 
                summary: summary, 
                detail: errorMessage,
                life: 5000 
            });
            // Re-throw the error so specific components can still handle it if needed
            return throwError(() => error);
        })
    );
};

Step 3: Register the Interceptor
For the interceptor to work, it must be registered in the application configuration.

File: src/app.config.ts

import { errorInterceptor } from './core/interceptors/error.interceptor';
// ... other imports
export const appConfig: ApplicationConfig = {
    providers: [
        // ...
        provideHttpClient(
            withFetch(), 
            withInterceptors([
                authInterceptor, 
                errorInterceptor // <--- Add this here
            ])
        ),
        // ...
    ]
};

Step 4: Verification

To verify the implementation:

Run the application (ng serve).
Trigger an error (e.g., attempt to login with invalid credentials).
Expected Result: A red toast notification appears at the top right with the exact error message returned by the backend (e.g., "Invalid credentials" or "Resource not found").

This completes the Centralized Error Handling cycle. Both Backend and Frontend are now synchronized over a standard error protocol.

Next Lecture Preview
Lecture 14 : Cloud Deployment (Azure / AWS)

Deploying backend, frontend, and database to the cloud with managed infrastructure services.

🧱 Lesson 13A: Centralized Error Handling & Validation Backend

Farrukh Rehman — Mon, 16 Feb 2026 05:39:09 +0000

Source Code Backend : https://github.com/farrukh1212cs/ECommerce-Backend.git

Source Code Frontend : https://github.com/farrukh1212cs/ECommerce-Frontend.git

🎯 Introduction
In this lesson, we implement a Centralized Error Handling mechanism for our ASP.NET Core Web API. Instead of using try-catch blocks in every controller action, we will use a Global Exception Middleware. This middleware will catch all unhandled exceptions, log them, and return a standardized JSON response to the client.

This approach ensures:

Consistency: All API errors follow the same structure.
Maintainability: Controllers remain clean and focused on business logic.
Security: We avoid leaking sensitive stack traces in production.

Step 1: Define the Standardized Error Response
First, we define a wrapper class that all error responses will use. This ensures the frontend always knows what format to expect.

File: ECommerce.Application/Common/ErrorResponse.cs

namespace ECommerce.Application.Common;

public class ErrorResponse
{
    public int StatusCode { get; set; }
    public string Message { get; set; } = string.Empty;
    public object? Details { get; set; }

    public ErrorResponse(int statusCode, string message, object? details = null)
    {
        StatusCode = statusCode;
        Message = message;
        Details = details;
    }
}

Step 2: Create Custom Domain Exceptions
We create custom exceptions in the Domain layer. These exceptions represent specific business scenarios (e.g., "Resource Not Found") and are independent of HTTP status codes. The middleware will map these to HTTP codes later.

File: ECommerce.Domain/Exceptions/NotFoundException.cs

namespace ECommerce.Domain.Exceptions;
public class NotFoundException : Exception
{
    public NotFoundException(string message) : base(message)
    {
    }
    public NotFoundException(string name, object key)
        : base($"Entity \"{name}\" ({key}) was not found.")
    {
    }
}

File: ECommerce.Domain/Exceptions/BadRequestException.cs

namespace ECommerce.Domain.Exceptions;
public class BadRequestException : Exception
{
    public BadRequestException(string message) : base(message)
    {
    }
}

Step 3: Implement the Global Middleware
This is the core component. It sits in the HTTP pipeline, catches exceptions, determines the appropriate HTTP status code, and writes the
ErrorResponse
JSON.

File: ECommerce.API/Middleware/ExceptionHandlingMiddleware.cs

using System.Net;
using System.Text.Json;
using ECommerce.Application.Common;
using ECommerce.Domain.Exceptions;
namespace ECommerce.API.Middleware;
public class ExceptionHandlingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<ExceptionHandlingMiddleware> _logger;
    private readonly IHostEnvironment _env;
    public ExceptionHandlingMiddleware(RequestDelegate next, ILogger<ExceptionHandlingMiddleware> logger, IHostEnvironment env)
    {
        _next = next;
        _logger = logger;
        _env = env;
    }
    public async Task InvokeAsync(HttpContext context)
    {
        try
        {
            await _next(context);
        }
        catch (Exception ex)
        {
            await HandleExceptionAsync(context, ex);
        }
    }
    private async Task HandleExceptionAsync(HttpContext context, Exception exception)
    {
        _logger.LogError(exception, "An unhandled exception has occurred: {Message}", exception.Message);
        context.Response.ContentType = "application/json";

        // Map specific exceptions to HTTP Status Codes
        var response = exception switch
        {
            NotFoundException => new ErrorResponse((int)HttpStatusCode.NotFound, exception.Message),
            BadRequestException => new ErrorResponse((int)HttpStatusCode.BadRequest, exception.Message),
            _ => new ErrorResponse((int)HttpStatusCode.InternalServerError, "An internal server error has occurred.", _env.IsDevelopment() ? exception.StackTrace : null)
        };
        context.Response.StatusCode = response.StatusCode;
        var json = JsonSerializer.Serialize(response, new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });
        await context.Response.WriteAsync(json);
    }
}

Step 4: Register the Middleware
Finally, we tell ASP.NET Core to use our middleware. The order matters! It should be registered early in the pipeline to catch errors from other middleware.

File: ECommerce.API/Program.cs

// ... existing code ...
var app = builder.Build();
// ------------------------------------------------------
// Middleware Pipeline
// ------------------------------------------------------
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}
// REGISTER MIDDLEWARE HERE
app.UseMiddleware<ECommerce.API.Middleware.ExceptionHandlingMiddleware>();
app.UseHttpsRedirection();
// ... rest of the pipeline

Step 5: Usage & Verification
Now, you can throw exceptions from anywhere in your Application or Domain layers, and they will be automatically handled.

Usage Example:

public async Task<ProductDto> GetProductById(Guid id)
{
    var product = await _repository.GetByIdAsync(id);
    if (product == null)
    {
        throw new NotFoundException(nameof(Product), id);
    }
    return _mapper.Map<ProductDto>(product);
}

Response Example (404 Not Found):

{
  "statusCode": 404,
  "message": "Entity \"Product\" (d290f1ee-6c54-4b01-90e6-d701748f0851) was not found.",
  "details": null
}

Next Lecture Preview
Lecture 13B : Centralized Error Handling & Validation Frontend

Using interceptor for error handling, implementing FluentValidation, and maintaining consistent API responses.

🧱 Lecture 12: Structured Logging & Monitoring

Farrukh Rehman — Thu, 12 Feb 2026 10:37:57 +0000

Source Code Backend : https://github.com/farrukh1212cs/ECommerce-Backend.git

Source Code Frontend : https://github.com/farrukh1212cs/ECommerce-Frontend.git

🎯 Introduction

Logging is the eyes and ears of your application. When things go wrong in production, a well-structured log file is often the only thing standing between a quick fix and a sleepless night. In this guide, we'll walk through how to implement Serilog in a .NET 8 Web API, configuring it to write structured JSON logs to separate files for Error, Information, and Debug levels.

Why Serilog?
Serilog is a diagnostic logging library for .NET applications. Unlike default logging, Serilog is built from the ground up to support structured data. This means your logs aren't just text strings; they are data objects that can be queried, filtered, and analyzed easily.

Step 1: Install the Essentials
First, we need to add the necessary NuGet packages to our project. These packages allow Serilog to integrate with ASP.NET Core, write to files, and format logs as JSON.

Run the following commands in your project directory:

dotnet add package Serilog.AspNetCore
dotnet add package Serilog.Sinks.File
dotnet add package Serilog.Formatting.Compact

Serilog.AspNetCore: Integrates Serilog with the ASP.NET Core framework.
Serilog.Sinks.File: Writes log events to files.
Serilog.Formatting.Compact: Formats logs as compact JSON, saving space and making them machine-readable.

Step 2: Configuration Magic
One of the most powerful features of Serilog is its ability to be configured entirely via appsettings.json. We want to separate our logs into three distinct files based on severity:

Error-yyyyMMdd.json: Critical issues that need immediate attention.
Info-yyyyMMdd.json: General application flow and operational events.
Debug-yyyyMMdd.json: Detailed diagnostic information for development and troubleshooting.

Open your
appsettings.json
and replace the default Logging section with this Serilog configuration:

{
  "Serilog": {
    "MinimumLevel": {
      "Default": "Information",
      "Override": {
        "Microsoft": "Warning",
        "System": "Warning"
      }
    },
    "WriteTo": [
      {
        "Name": "File",
        "Args": {
          "path": "logs/Error-.json",
          "restrictedToMinimumLevel": "Error",
          "rollingInterval": "Day",
          "formatter": "Serilog.Formatting.Compact.CompactJsonFormatter, Serilog.Formatting.Compact"
        }
      },
      {
        "Name": "File",
        "Args": {
          "path": "logs/Info-.json",
          "restrictedToMinimumLevel": "Information",
          "rollingInterval": "Day",
          "formatter": "Serilog.Formatting.Compact.CompactJsonFormatter, Serilog.Formatting.Compact"
        }
      },
      {
        "Name": "File",
        "Args": {
          "path": "logs/Debug-.json",
          "restrictedToMinimumLevel": "Debug",
          "rollingInterval": "Day",
          "formatter": "Serilog.Formatting.Compact.CompactJsonFormatter, Serilog.Formatting.Compact"
        }
      }
    ]
  }
}

Key Configurations:

rollingInterval: Sets the log file to roll over every Day, creating files like Error-20231025.json.
restrictedToMinimumLevel: Ensures that the "Error" file only contains errors (and higher), while "Info" captures information and above.
formatter: Uses the CompactJsonFormatter to output clean, structured JSON.

Step 3: Wire It Up in Program.cs
Now, let's hook Serilog into the application startup pipeline. We'll configure it to load settings from our JSON configuration and replace the default logger. We also want to wrap our application startup in a try/catch block to capture any fatal errors that prevent the app from starting.

Update Program.cs

using Serilog;
// 1. Initialize the bootstrap logger
Log.Logger = new LoggerConfiguration()
    .WriteTo.Console()
    .CreateBootstrapLogger();
try
{
    var builder = WebApplication.CreateBuilder(args);

    // 2. Add Serilog to the Host
    builder.Host.UseSerilog((context, services, configuration) => configuration
        .ReadFrom.Configuration(context.Configuration)
        .ReadFrom.Services(services)
        .Enrich.FromLogContext());
    // ... (Rest of your service registrations) ...
    var app = builder.Build();
    // ... (Middleware pipeline) ...
    app.Run();
}
catch (Exception ex)
{
    // 3. Capture fatal startup errors
    Log.Fatal(ex, "Application terminated unexpectedly");
}
finally
{
    // 4. Ensure logs are flushed before exit
    Log.CloseAndFlush();
}

The Result
Run your application, and you will see a logs folder appear in your project root. Inside, you'll find your structured JSON log files:

logs/Error-20260206.json
logs/Info-20260206.json
logs/Debug-20260206.json
Each line in these files is a valid JSON object, making it incredibly easy to ingest into log management tools like Datadog, Splunk,Seq, or the ELK stack (Elasticsearch, Logstash, Kibana).

Conclusion
By implementing structured logging with Serilog, you've moved beyond simple text files to a robust, queryable logging infrastructure. Configuring separate files for different log levels ensures that critical errors don't get lost in the noise of information logs, helping you maintain a healthy and debuggable application.

Next Lecture Preview
Lecture 13 : Centralized Error Handling & Validation

Using middleware for error handling, implementing FluentValidation, and maintaining consistent API responses.

🧱 Lecture 11: Continuous Integration and Continuous Deployment (CI/CD) with Jenkins

Farrukh Rehman — Tue, 20 Jan 2026 14:22:29 +0000

Source Code Backend : https://github.com/farrukh1212cs/ECommerce-Backend.git

Source Code Frontend : https://github.com/farrukh1212cs/ECommerce-Frontend.git

🎯 Introduction

In modern software development, manual builds and deployments are no longer sustainable. Teams need speed, reliability, and consistency. This is exactly what Continuous Integration (CI) and Continuous Deployment (CD) provide.

Jenkins is one of the most powerful tools for implementing CI/CD. It enables teams to automate everything from code integration to production deployment.

In this lecture, you will learn:

What CI/CD really means in practice
How Jenkins works
How to write pipelines using Jenkinsfile
How to automate build, test, and deployment
Best practices used in professional teams
This is a practical, industry-aligned guide.

What is Continuous Integration (CI)?

Continuous Integration is the practice of frequently merging code into a shared repository and automatically validating every change.

A typical CI workflow:

Developer pushes code to GitHub
Pipeline automatically triggers
Application builds
Tests run
Feedback is provided immediately

Why CI Matters

Bugs are caught early
Integration conflicts are reduced
Code quality improves
Teams ship faster with confidence

Without CI, teams often discover problems too late — during release.

What is Continuous Deployment (CD)?

Continuous Deployment goes one step further.

After code passes:

Build
Tests
Quality checks

…it is automatically deployed to environments like staging or production.

Some teams use:

Continuous Delivery → Deployment requires manual approval
Continuous Deployment → Deployment is fully automatic

Both models are common in professional environments.

What is Jenkins?

Jenkins is an open-source automation server that allows you to build complete CI/CD pipelines.

With Jenkins, you can:

Pull code from repositories
Build applications
Run automated tests
Perform static code analysis
Deploy applications
Trigger workflows across tools

Jenkins is popular because:

It is free and open-source
It supports thousands of plugins
It works with almost any tech stack
It scales from small teams to large enterprises

Jenkins Architecture (Simplified)

Jenkins typically consists of:

Jenkins Controller (Master)

Manages jobs
Provides UI
Schedules pipelines
Handles configuration

Jenkins Agents (Workers)

Execute the actual builds
Can run on separate machines
Useful for scaling pipelines

Pipelines

Define the automation workflow
Written as code using a Jenkinsfile

Lets Write our Jenkinsfile

for backend .net application

pipeline {
    agent any
     options {
        disableConcurrentBuilds()
    }   
    stages {
        stage('Build') {
            steps {
                script {
                    // Remove previous image with the <none> tag  testing
                    sh 'docker rmi ecom-backend:latest || true'

                    // Build the new image with an explicit tag  
                    sh 'docker build --no-cache -t ecom-backend:latest -f ECommerce.API/Dockerfile .'

                    // Remove dangling images
                    sh 'docker images -q --filter "dangling=true" | xargs docker rmi || true'

                    // Clean up intermediate images
                    sh 'docker image prune -f'

                    // Custom cleanup script to remove any remaining <none> tagged images
                    sh '''
                        for image_id in $(docker images --filter "dangling=true" -q); do
                            docker rmi $image_id || true
                        done
                    '''
                }
            }
        }
        stage('Push and Deploy') {
            steps {                
                script {
                    // Stop and remove the container if it exists
                    sh 'docker stop ecom-backend || true'
                    sh 'docker rm ecom-backend || true'

                    // Run the new container
                    sh 'docker run -d --restart always --name ecom-backend --env "ASPNETCORE_ENVIRONMENT=Development" --network zohan -p 8202:8080 ecom-backend:latest'

                     sh 'docker image prune -f'
                }
            }
        }
    }
}

Lets Write for Frontend

pipeline {
    agent any
     options {
        disableConcurrentBuilds()
    }   
    stages {       

        stage('Build') {
            steps {
                sh 'docker build --no-cache -t ecom-front/ui -f Dockerfile .'
            }
        }
        stage('Push and Deploy') {
            steps {                
                sh 'docker stop ecom-front || true && docker rm ecom-front || true'
                sh 'docker run -d --restart always --name ecom-front --network zohan -p 9201:80 ecom-front/ui:latest'

            }
        }
    }
}

Now time to Work on Jenkin

New Item

For Frontend do same process , just update the Repo URL and branch.

Next Lecture Preview
Lecture 12 : Structured Logging & Monitoring

Configuring Serilog with Seq or ELK Stack for centralized structured logging and observability.

🧱 Lecture 10 : Dockerizing the Full Stack Application

Farrukh Rehman — Mon, 22 Dec 2025 14:47:51 +0000

Source Code Backend : https://github.com/farrukh1212cs/ECommerce-Backend.git

Source Code Frontend : https://github.com/farrukh1212cs/ECommerce-Frontend.git

🎯 Introduction
In modern software engineering, containerization is a fundamental skill for building portable, scalable, and DevOps-friendly applications. By packaging both the .NET 8 backend API and the Angular Admin Panel inside Docker containers, we ensure that the entire application stack can run consistently across any environment—local, QA, staging, or production—without dependency conflicts or manual setup.

This lesson focuses exclusively on:

Creating a Dockerfile for the .NET 8 E-Commerce API
Creating a Dockerfile for the Angular Admin App (using the Mantis free template)
Running both applications in isolated Docker containers
Configuring docker-compose to orchestrate both services together

After completing this lesson, you will be able to launch the entire backend + admin panel with one command:

docker-compose up --build -d

This is an essential step toward production readiness and CI/CD automation in future lessons.

Section 1 — Dockerizing the .NET 8 Backend API

FIRST OF ALL WE NEED TO UPDATE PROGRAM FILE FOR AUTO RUN MIGRATIONS

We will create a multi-stage Dockerfile that:

Restores dependencies
Publishes the project
Runs the optimized build inside ASP.NET Core runtime

Step 1.1 — Create Dockerfile in your API project root

Location:
Path : "/ECommerce.API/Dockerfile"
Right-click the API project, select Add, and then choose Container Support to enable containerization for the service.

Lets Configure Docker Containers to connect each other.

First Create Docker Network
docker network create ecommerce-net

Lets Connect Postgres to this Network (ecommerce-net)
docker network connect ecommerce-net postgres

Now time to connect RabbitMQ to network (ecommerce-net)
docker network connect ecommerce-net rabbitmq

Its time to connect Redis with the network (ecommerce-net)

docker network connect ecommerce-net ecommerce-redis

Last setp lets verify Network

docker inspect ecommerce-net

All Containers are Connected with our network.now its time to work on api side.

Copy all configuration values from appsettings.json into appsettings.Development.json
Update appsettings.Development.json Replace localhost from ConnectionStrings:PostgreSQL to ContainerName (postgres)
Update Redis localhost to ContainerName (ecommerce-redis)
Update RabbitMQ localhost to ContainerName (rabbitmq)

Lets try to Build Image (make sure docker is running)

docker build -t ecommerce-api -f ECommerce.API/Dockerfile .

docker images

Run the API Container

docker run -p 5000:8080 --name ecommerce-api-container --network ecommerce-net -e ASPNETCORE_ENVIRONMENT=Development ecommerce-api

Its time to Test Swagger our container is accessable on port 5000

Lets start working on angular containerization
we need to create four files
Dockerfile,.dockerignore,nginx.conf,environment.prod.ts
Path: "ecommerce-backoffice\Dockerfile"

FROM node:20.19-alpine AS build

WORKDIR /app

# Install dependencies (use npm ci for reproducible installs)
COPY package.json package-lock.json* ./
RUN npm ci --silent || npm install --silent

# Copy source and build the Angular app
COPY . .
RUN npm run build -- --configuration=production

FROM nginx:stable-alpine

# Remove default nginx static assets
RUN rm -rf /usr/share/nginx/html/*

# Copy built Angular app from the builder stage
COPY --from=build /app/dist/sakai-ng/browser  /usr/share/nginx/html

# Expose port 80
EXPOSE 80

# Start nginx in the foreground
CMD ["nginx", "-g", "daemon off;"]

Path: "ecommerce-backoffice.dockerignore"
.dockerignore

node_modules
dist
.git
.gitignore
Dockerfile
docker-compose*.yml
docker-compose*.yaml
README.md
*.log
.vscode
.idea
coverage
tmp
out-tsc
# keep source files included so the build can run

Path: "ecommerce-backoffice\nginx.conf"
nginx.conf

server {
    listen 80;
    server_name localhost;

    # Serve the Angular app
    location / {
        root /usr/share/nginx/html;
        try_files $uri $uri/ /index.html;
        add_header Cache-Control "no-cache, no-store, must-revalidate";
    }

    # Proxy API requests to your backend
    location /api/ {
        proxy_pass https://host.docker.internal:7104;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_cache_bypass $http_upgrade;

        # Disable SSL verification (for self-signed certs in local dev)
        proxy_ssl_verify off;
        proxy_ssl_session_reuse on;
    }
}

Path: "ecommerce-backoffice\src\environments\environment.prod.ts"
environment.prod.ts

export const environment = {
  production: true,
  // API requests are proxied through nginx to the backend
    baseUrl: 'http://localhost:7104/api'
};

Its time to build Angular Image

docker build -t sakai-ng:latest .

docker images
docker run --rm -p 80:80 sakai-ng:latest

Final Step Lets Write docker-compose.yml

networks:
  ecommerce-net:
    external: true

services:
  postgres:
    image: postgres:15
    container_name: postgres
    restart: unless-stopped
    environment:
      POSTGRES_DB: ECommerceDb
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: Admin123!
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - ecommerce-net

  rabbitmq:
    image: rabbitmq:3-management
    container_name: rabbitmq
    restart: unless-stopped
    ports:
      - "5672:5672"
      - "15672:15672"
    networks:
      - ecommerce-net

  redis:
    image: redis:7
    container_name: ecommerce-redis
    restart: unless-stopped
    ports:
      - "6379:6379"
    networks:
      - ecommerce-net

  ecommerce-api:
    image: ecommerce-api
    container_name: ecommerce-api-container
    restart: unless-stopped
    ports:
      - "7104:8080"
    environment:
      ASPNETCORE_ENVIRONMENT: Development
      ConnectionStrings__PostgreSQL: Host=postgres;Port=5432;Database=ECommerceDb;Username=postgres;Password=Admin123!
      Redis__Host: redis
      RabbitMQ__Host: rabbitmq
    depends_on:
      - postgres
      - rabbitmq
      - redis
    networks:
      - ecommerce-net

  sakai-ng:
    image: sakai-ng:latest
    container_name: sakai-ng
    restart: unless-stopped
    ports:
      - "80:80"
    depends_on:
      - ecommerce-api
    networks:
      - ecommerce-net

volumes:
  postgres_data:

Lets Test from UI

Next Lecture Preview
Lecture 11 : Continuous Integration with Jenkins

Creating CI/CD pipelines in Jenkins for automated build, test, and deployment workflows.

🧱 Lecture 9B : Product Management (Angular)

Farrukh Rehman — Fri, 05 Dec 2025 05:54:53 +0000

Source Code Backend : https://github.com/farrukh1212cs/ECommerce-Backend.git

Source Code Frontend : https://github.com/farrukh1212cs/ECommerce-Frontend.git

🎯 Introduction
This module focuses on building complete product management functionality, including full CRUD operations and seamless integration between the frontend interface and backend APIs. It ensures that users can create, update, view, and delete products efficiently while maintaining a smooth and responsive experience across the system.

This system will allow your administrators to:

Manage products

Communicate with the backend APIs you’ve already built

This lecture covers everything in one place:

- Auth Guard
- Full CRUD page for Product
- Product Service
- Product Route
- Update App Routes
- Update Menu

1. - Auth Guard
Path : "src/app/services/authguard/auth-guard.service.ts"

auth-guard.service.ts

import { Injectable } from '@angular/core';
import { Router } from '@angular/router';
import { AuthApiService } from '../api/auth.service';

@Injectable({
  providedIn: 'root'
})
export class AuthGuardService {
  constructor(
    private authService: AuthApiService,
    private router: Router
  ) {}

  canActivate(): boolean {
    const token = this.authService.getToken();
    const refreshToken = this.authService.getRefreshToken();

    // If no token and no refresh token, redirect to login
    if (!token && !refreshToken) {
      this.router.navigate(['/auth/login']);
      return false;
    }

    // If no token but refresh token exists, try to refresh
    if (!token && refreshToken) {
      this.attemptTokenRefresh(refreshToken);
      return false; // Wait for refresh attempt
    }

    // If token exists, user is authenticated
    if (token) {
      return true;
    }

    return false;
  }

  private attemptTokenRefresh(refreshToken: string): void {
    this.authService.refresh({ token: '', refreshToken }).subscribe({
      next: () => {
        // Token refreshed successfully, reload current route
        this.router.navigate([this.router.url]);
      },
      error: () => {
        // Refresh failed, redirect to login
        this.authService.logout();
        this.router.navigate(['/auth/login']);
      }
    });
  }
}

2. - UI Pages using PrimeNG
Create 3 Files for Product
Path : "src/app/features/products/product/product.html"
"src/app/features/products/product/product.scss" (blank file)
"src/app/features/products/product/product.ts"

product.html

<p-toolbar styleClass="mb-6">
    <ng-template #start>
        <p-button label="New" icon="pi pi-plus" severity="secondary" class="mr-2" (onClick)="openNew()" />
        <p-button severity="secondary" label="Delete" icon="pi pi-trash" outlined (onClick)="deleteSelectedProducts()" [disabled]="!selectedProducts || !selectedProducts.length" />
    </ng-template>

    <ng-template #end>
        <p-button label="Export" icon="pi pi-upload" severity="secondary" (onClick)="exportCSV()" />
    </ng-template>
</p-toolbar>

<p-table
    #dt
    [value]="products()"
    [rows]="10"
    [columns]="cols"
    [paginator]="true"
    [globalFilterFields]="['name', 'country.name', 'representative.name', 'status']"
    [tableStyle]="{ 'min-width': '75rem' }"
    [(selection)]="selectedProducts"
    [rowHover]="true"
    dataKey="id"
    currentPageReportTemplate="Showing {first} to {last} of {totalRecords} products"
    [showCurrentPageReport]="true"
    [rowsPerPageOptions]="[10, 20, 30]"
>
    <ng-template #caption>
        <div class="flex items-center justify-between">
            <h5 class="m-0">Manage Products</h5>
            <p-iconfield>
                <p-inputicon styleClass="pi pi-search" />
                <input pInputText type="text" (input)="onGlobalFilter(dt, $event)" placeholder="Search..." />
            </p-iconfield>
        </div>
    </ng-template>
    <ng-template #header>
        <tr>
            <th style="width: 3rem">
                <p-tableHeaderCheckbox />
            </th>
            <th style="min-width: 8rem">ID</th>
            <th pSortableColumn="name" style="min-width:16rem">
                Name
                <p-sortIcon field="name" />
            </th>
            <th pSortableColumn="description" style="min-width:16rem">
                Description
                <p-sortIcon field="description" />
            </th>
            <th pSortableColumn="price" style="min-width: 8rem">
                Price
                <p-sortIcon field="price" />
            </th>
            <th pSortableColumn="stock" style="min-width: 8rem">
                Stock
                <p-sortIcon field="stock" />
            </th>
            <th style="min-width: 12rem"></th>
        </tr>
    </ng-template>
    <ng-template #body let-product>
        <tr>
            <td style="width: 3rem">
                <p-tableCheckbox [value]="product" />
            </td>
            <td style="min-width: 8rem">{{ product.id }}</td>
            <td style="min-width: 16rem">{{ product.name }}</td>
            <td style="min-width: 16rem">{{ product.description }}</td>
            <td>{{ product.price | currency: 'USD' }}</td>
            <td>{{ product.stock }}</td>
            <td>
                <p-button icon="pi pi-pencil" class="mr-2" [rounded]="true" [outlined]="true" (click)="editProduct(product)" />
                <p-button icon="pi pi-trash" severity="danger" [rounded]="true" [outlined]="true" (click)="deleteProduct(product)" />
            </td>
        </tr>
    </ng-template>
</p-table>

<p-dialog [(visible)]="productDialog" [style]="{ width: '450px' }" header="Product Details" [modal]="true">
    <ng-template #content>
        <div class="flex flex-col gap-6">
            <div>
                <label for="name" class="block font-bold mb-3">Name</label>
                <input type="text" pInputText id="name" [(ngModel)]="product.name" required autofocus fluid />
                <small class="text-red-500" *ngIf="submitted && !product.name">Name is required.</small>
            </div>
            <div>
                <label for="description" class="block font-bold mb-3">Description</label>
                <textarea id="description" pTextarea [(ngModel)]="product.description" required rows="3" cols="20" fluid></textarea>
            </div>
            <div class="grid grid-cols-12 gap-4">
                <div class="col-span-6">
                    <label for="price" class="block font-bold mb-3">Price</label>
                    <p-inputnumber id="price" [(ngModel)]="product.price" mode="currency" currency="USD" locale="en-US" fluid />
                </div>
                <div class="col-span-6">
                    <label for="stock" class="block font-bold mb-3">Stock</label>
                    <p-inputnumber id="stock" [(ngModel)]="product.stock" fluid />
                </div>
            </div>
        </div>
    </ng-template>

    <ng-template #footer>
        <p-button label="Cancel" icon="pi pi-times" text (click)="hideDialog()" />
        <p-button label="Save" icon="pi pi-check" (click)="saveProduct()" />
    </ng-template>
</p-dialog>

<p-confirmdialog [style]="{ width: '450px' }" />

product.scss

product.ts

import { Component, OnInit, signal, ViewChild } from '@angular/core';
import { ConfirmationService, MessageService } from 'primeng/api';
import { Table, TableModule } from 'primeng/table';
import { CommonModule } from '@angular/common';
import { FormsModule } from '@angular/forms';
import { ButtonModule } from 'primeng/button';
import { RippleModule } from 'primeng/ripple';
import { ToastModule } from 'primeng/toast';
import { ToolbarModule } from 'primeng/toolbar';
import { RatingModule } from 'primeng/rating';
import { InputTextModule } from 'primeng/inputtext';
import { TextareaModule } from 'primeng/textarea';
import { SelectModule } from 'primeng/select';
import { RadioButtonModule } from 'primeng/radiobutton';
import { InputNumberModule } from 'primeng/inputnumber';
import { DialogModule } from 'primeng/dialog';
import { TagModule } from 'primeng/tag';
import { InputIconModule } from 'primeng/inputicon';
import { IconFieldModule } from 'primeng/iconfield';
import { ConfirmDialogModule } from 'primeng/confirmdialog';
import { ProductDto, ProductApiService } from '../../../services/api/product.service';

interface Column {
    field: string;
    header: string;
    customExportHeader?: string;
}

interface ExportColumn {
    title: string;
    dataKey: string;
}

@Component({
  selector: 'app-product',
  standalone: true,
  imports: [
    CommonModule,
    TableModule,
    FormsModule,
    ButtonModule,
    RippleModule,
    ToastModule,
    ToolbarModule,
    RatingModule,
    InputTextModule,
    TextareaModule,
    SelectModule,
    RadioButtonModule,
    InputNumberModule,
    DialogModule,
    TagModule,
    InputIconModule,
    IconFieldModule,
    ConfirmDialogModule
  ],
  templateUrl: './product.html',
  styleUrl: './product.scss',
    providers: [MessageService, ConfirmationService]
})
export class Product implements OnInit {
    productDialog: boolean = false;
    products = signal<ProductDto[]>([]);
    product!: ProductDto;
    selectedProducts!: ProductDto[] | null;
    submitted: boolean = false;
    @ViewChild('dt') dt!: Table;
    exportColumns!: ExportColumn[];
    cols!: Column[];

    constructor(
        private productApi: ProductApiService,
        private messageService: MessageService,
        private confirmationService: ConfirmationService
    ) {}

    exportCSV() {
        this.dt.exportCSV();
    }

    ngOnInit() {
        this.loadProducts();
        this.cols = [
            { field: 'id', header: 'ID' },
            { field: 'name', header: 'Name' },
            { field: 'description', header: 'Description' },
            { field: 'price', header: 'Price' },
            { field: 'stock', header: 'Stock' }
        ];
        this.exportColumns = this.cols.map((col) => ({ title: col.header, dataKey: col.field }));
    }

    loadProducts() {
        this.productApi.list().subscribe((data) => {
            this.products.set(data);
        });
    }

    onGlobalFilter(table: Table, event: Event) {
        table.filterGlobal((event.target as HTMLInputElement).value, 'contains');
    }

    openNew() {
        // Do not set `id` (omit it) so backend can accept/create without GUID parsing errors
        this.product = { name: '', description: '', price: 0, stock: 0 } as ProductDto;
        this.submitted = false;
        this.productDialog = true;
    }

    editProduct(product: ProductDto) {
        this.product = { ...product };
        this.productDialog = true;
    }

    deleteSelectedProducts() {
        this.confirmationService.confirm({
            message: 'Are you sure you want to delete the selected products?',
            header: 'Confirm',
            icon: 'pi pi-exclamation-triangle',
            accept: () => {
                if (this.selectedProducts) {
                    this.selectedProducts.forEach(product => {
                        if (product.id) {
                            this.productApi.delete(product.id).subscribe(() => {
                                this.loadProducts();
                            });
                        }
                    });
                    this.selectedProducts = null;
                    this.messageService.add({
                        severity: 'success',
                        summary: 'Successful',
                        detail: 'Products Deleted',
                        life: 3000
                    });
                }
            }
        });
    }

    hideDialog() {
        this.productDialog = false;
        this.submitted = false;
    }

    deleteProduct(product: ProductDto) {
        this.confirmationService.confirm({
            message: 'Are you sure you want to delete ' + product.name + '?',
            header: 'Confirm',
            icon: 'pi pi-exclamation-triangle',
            accept: () => {
                if (product.id) {
                    this.productApi.delete(product.id).subscribe(() => {
                        this.loadProducts();
                        this.messageService.add({
                            severity: 'success',
                            summary: 'Successful',
                            detail: 'Product Deleted',
                            life: 3000
                        });
                    });
                }
            }
        });
    }

    findIndexById(id: string): number {
        let index = -1;
        for (let i = 0; i < this.products().length; i++) {
            if (this.products()[i].id === id) {
                index = i;
                break;
            }
        }

        return index;
    }

    createId(): string {
        let id = '';
        var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
        for (var i = 0; i < 5; i++) {
            id += chars.charAt(Math.floor(Math.random() * chars.length));
        }
        return id;
    }

    getSeverity(status: string) {
        switch (status) {
            case 'INSTOCK':
                return 'success';
            case 'LOWSTOCK':
                return 'warn';
            case 'OUTOFSTOCK':
                return 'danger';
            default:
                return 'info';
        }
    }

    saveProduct() {
        this.submitted = true;
        if (this.product.name?.trim()) {
            if (this.product.id) {
                this.productApi.update(this.product.id, this.product).subscribe(() => {
                    this.loadProducts();
                    this.messageService.add({
                        severity: 'success',
                        summary: 'Successful',
                        detail: 'Product Updated',
                        life: 3000
                    });
                });
            } else {
                this.productApi.create(this.product).subscribe((created) => {
                    this.loadProducts();
                    this.messageService.add({
                        severity: 'success',
                        summary: 'Successful',
                        detail: 'Product Created',
                        life: 3000
                    });
                });
            }
            this.productDialog = false;
        }
    }
}

3. - Product Services
Create Product Service
Path : "/src/app/services/api/product.service.ts"

product.service.ts

import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
// Try to read API base url from environment; fallback to '/api' when not set
import { environment } from '../../../environments/environment';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';

// Match backend ProductDto
export interface ProductDto {
  id?: string;
  name: string;
  description: string;
  price: number;
  stock: number;
}

interface ApiListResponse<T> {
  fromCache: boolean;
  data: T;
}

@Injectable({
  providedIn: 'root'
})
export class ProductApiService {
  private baseUrl = environment.baseUrl + '/products';

  constructor(private http: HttpClient) {}

  // Returns product[] (unwrapped from { fromCache, data })
  list(): Observable<ProductDto[]> {
    return this.http
      .get<ApiListResponse<ProductDto[]>>(this.baseUrl)
      .pipe(map((res) => res.data));
  }

  // Returns single product (unwrapped)
  get(id: string): Observable<ProductDto> {
    return this.http
      .get<ApiListResponse<ProductDto>>(`${this.baseUrl}/${id}`)
      .pipe(map((res) => res.data));
  }

  // Create returns created product (controller returns dto in body)
  create(product: ProductDto): Observable<ProductDto> {
    return this.http.post<ProductDto>(this.baseUrl, product);
  }

  // Update returns no content; use void
  update(id: string, product: ProductDto): Observable<void> {
    return this.http.put<void>(`${this.baseUrl}/${id}`, product);
  }

  delete(id: string): Observable<void> {
    return this.http.delete<void>(`${this.baseUrl}/${id}`);
  }
}

4. - Product Route
Create New File for Product Ruting
Path : "src/app/features/products/products.routes.ts"

import { Routes } from '@angular/router';
import { Product } from './product/product';

export default [
    { path: '', component: Product }
] as Routes;

4. - Update App Routes
Path : "src/app/app.routes.ts"

import { Routes } from '@angular/router';
import { AppLayout } from './app/layout/component/app.layout';
import { Dashboard } from './app/pages/dashboard/dashboard';
import { Documentation } from './app/pages/documentation/documentation';
import { Landing } from './app/pages/landing/landing';
import { Notfound } from './app/pages/notfound/notfound';
import { AuthGuardService } from './app/services/authguard/auth-guard.service';

export const appRoutes: Routes = [
    {
        path: '',
        redirectTo: () => {
            const token = localStorage.getItem('auth_token');
            return token ? '/dashboard' : '/auth/login';
        },
        pathMatch: 'full'
    },
    {
        path: 'dashboard',
        component: AppLayout,
        canActivate: [AuthGuardService],
        children: [
            { path: '', component: Dashboard }
        ]
    },
    {
        path: 'products',
        component: AppLayout,
        canActivate: [AuthGuardService],
        children: [
            { path: '', loadChildren: () => import('./app/features/products/products.routes') }
        ]
    },
    {
        path: 'uikit',
        component: AppLayout,
        canActivate: [AuthGuardService],
        children: [
            { path: '', loadChildren: () => import('./app/pages/uikit/uikit.routes') }
        ]
    },
    {
        path: 'pages',
        component: AppLayout,
        canActivate: [AuthGuardService],
        children: [
            { path: '', loadChildren: () => import('./app/pages/pages.routes') }
        ]
    },
    {
        path: 'documentation',
        component: AppLayout,
        canActivate: [AuthGuardService],
        children: [
            { path: '', component: Documentation }
        ]
    },
    { path: 'landing', component: Landing },
    { path: 'notfound', component: Notfound },
    { path: 'auth', loadChildren: () => import('./app/features/auth/auth.routes') },
    { path: '**', component: Notfound }
];

5. - Update App Menu
Path : "src/app/layout/component/app.menu.ts"

import { Component } from '@angular/core';
import { CommonModule } from '@angular/common';
import { RouterModule } from '@angular/router';
import { MenuItem } from 'primeng/api';
import { AppMenuitem } from './app.menuitem';

@Component({
    selector: 'app-menu',
    standalone: true,
    imports: [CommonModule, AppMenuitem, RouterModule],
    template: `<ul class="layout-menu">
        <ng-container *ngFor="let item of model; let i = index">
            <li app-menuitem *ngIf="!item.separator" [item]="item" [index]="i" [root]="true"></li>
            <li *ngIf="item.separator" class="menu-separator"></li>
        </ng-container>
    </ul> `
})
export class AppMenu {
    model: MenuItem[] = [];

    ngOnInit() {
        this.model = [
            {
                label: 'Home',
                items: [{ label: 'Dashboard', icon: 'pi pi-fw pi-home', routerLink: ['/dashboard'] }]
            },
            {
                label: 'Products',
                items: [{ label: 'Products', icon: 'pi pi-fw pi-home', routerLink: ['/products'] }]
            },
            {
                label: 'UI Components',
                items: [
                    { label: 'Form Layout', icon: 'pi pi-fw pi-id-card', routerLink: ['/uikit/formlayout'] },
                    { label: 'Input', icon: 'pi pi-fw pi-check-square', routerLink: ['/uikit/input'] },
                    { label: 'Button', icon: 'pi pi-fw pi-mobile', class: 'rotated-icon', routerLink: ['/uikit/button'] },
                    { label: 'Table', icon: 'pi pi-fw pi-table', routerLink: ['/uikit/table'] },
                    { label: 'List', icon: 'pi pi-fw pi-list', routerLink: ['/uikit/list'] },
                    { label: 'Tree', icon: 'pi pi-fw pi-share-alt', routerLink: ['/uikit/tree'] },
                    { label: 'Panel', icon: 'pi pi-fw pi-tablet', routerLink: ['/uikit/panel'] },
                    { label: 'Overlay', icon: 'pi pi-fw pi-clone', routerLink: ['/uikit/overlay'] },
                    { label: 'Media', icon: 'pi pi-fw pi-image', routerLink: ['/uikit/media'] },
                    { label: 'Menu', icon: 'pi pi-fw pi-bars', routerLink: ['/uikit/menu'] },
                    { label: 'Message', icon: 'pi pi-fw pi-comment', routerLink: ['/uikit/message'] },
                    { label: 'File', icon: 'pi pi-fw pi-file', routerLink: ['/uikit/file'] },
                    { label: 'Chart', icon: 'pi pi-fw pi-chart-bar', routerLink: ['/uikit/charts'] },
                    { label: 'Timeline', icon: 'pi pi-fw pi-calendar', routerLink: ['/uikit/timeline'] },
                    { label: 'Misc', icon: 'pi pi-fw pi-circle', routerLink: ['/uikit/misc'] }
                ]
            },
            {
                label: 'Pages',
                icon: 'pi pi-fw pi-briefcase',
                routerLink: ['/pages'],
                items: [
                    {
                        label: 'Landing',
                        icon: 'pi pi-fw pi-globe',
                        routerLink: ['/landing']
                    },
                    {
                        label: 'Auth',
                        icon: 'pi pi-fw pi-user',
                        items: [
                            {
                                label: 'Login',
                                icon: 'pi pi-fw pi-sign-in',
                                routerLink: ['/auth/login']
                            },
                            {
                                label: 'Error',
                                icon: 'pi pi-fw pi-times-circle',
                                routerLink: ['/auth/error']
                            },
                            {
                                label: 'Access Denied',
                                icon: 'pi pi-fw pi-lock',
                                routerLink: ['/auth/access']
                            }
                        ]
                    },
                    {
                        label: 'Crud',
                        icon: 'pi pi-fw pi-pencil',
                        routerLink: ['/pages/crud']
                    },
                    {
                        label: 'Not Found',
                        icon: 'pi pi-fw pi-exclamation-circle',
                        routerLink: ['/pages/notfound']
                    },
                    {
                        label: 'Empty',
                        icon: 'pi pi-fw pi-circle-off',
                        routerLink: ['/pages/empty']
                    }
                ]
            },
            {
                label: 'Hierarchy',
                items: [
                    {
                        label: 'Submenu 1',
                        icon: 'pi pi-fw pi-bookmark',
                        items: [
                            {
                                label: 'Submenu 1.1',
                                icon: 'pi pi-fw pi-bookmark',
                                items: [
                                    { label: 'Submenu 1.1.1', icon: 'pi pi-fw pi-bookmark' },
                                    { label: 'Submenu 1.1.2', icon: 'pi pi-fw pi-bookmark' },
                                    { label: 'Submenu 1.1.3', icon: 'pi pi-fw pi-bookmark' }
                                ]
                            },
                            {
                                label: 'Submenu 1.2',
                                icon: 'pi pi-fw pi-bookmark',
                                items: [{ label: 'Submenu 1.2.1', icon: 'pi pi-fw pi-bookmark' }]
                            }
                        ]
                    },
                    {
                        label: 'Submenu 2',
                        icon: 'pi pi-fw pi-bookmark',
                        items: [
                            {
                                label: 'Submenu 2.1',
                                icon: 'pi pi-fw pi-bookmark',
                                items: [
                                    { label: 'Submenu 2.1.1', icon: 'pi pi-fw pi-bookmark' },
                                    { label: 'Submenu 2.1.2', icon: 'pi pi-fw pi-bookmark' }
                                ]
                            },
                            {
                                label: 'Submenu 2.2',
                                icon: 'pi pi-fw pi-bookmark',
                                items: [{ label: 'Submenu 2.2.1', icon: 'pi pi-fw pi-bookmark' }]
                            }
                        ]
                    }
                ]
            },
            {
                label: 'Get Started',
                items: [
                    {
                        label: 'Documentation',
                        icon: 'pi pi-fw pi-book',
                        routerLink: ['/documentation']
                    },
                    {
                        label: 'View Source',
                        icon: 'pi pi-fw pi-github',
                        url: 'https://github.com/primefaces/sakai-ng',
                        target: '_blank'
                    }
                ]
            }
        ];
    }
}

Next Lecture Preview
Lecture 10 : Dockerizing the Full Stack Application

Writing Dockerfiles for .NET and Angular/React, setting up docker-compose for local orchestration.

🧱 Lesson 9A - Login and Authentication (Angular)

Farrukh Rehman — Thu, 27 Nov 2025 09:19:05 +0000

Source Code Backend : https://github.com/farrukh1212cs/ECommerce-Backend.git

Source Code Frontend : https://github.com/farrukh1212cs/ECommerce-Frontend.git

🎯 Introduction

In this lecture, we develop a full Backoffice Admin Panel using Angular 20 and we will use PrimeNg Free Template sakai-ng.

This system will allow your administrators to:

Manage products
Manage customers
View orders
Update settings
Handle security & authorization

Communicate with the backend APIs you’ve already built

We will also integrate authentication using JWT, and create a clean, scalable Angular architecture.

This lecture covers everything in one place:

- Angular environment setup
- Folder structure
- Services + Models
- Authentication + Interceptor
- Move Login Component Features
- Update App Routes
- Update App Config
- Testing

1. - Angular environment setup We will Use Free Version of PrimeNG (sakai-ng)

Clone Project
git clone https://github.com/primefaces/sakai-ng

Create New environment files
Path: "/src/environments/environment.ts" and "/src/environments/environment.prod.ts"

export const environment = {
  production: false,
  // Set your API base URL here, e.g. 'https://api.example.com'
    baseUrl: 'https://localhost:7104/api'
};

2. - Folder structure

3. - Services + Models
Create Auth Service
Path : "/src/app/services/api/auth.service.ts"

auth.service.ts

import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable } from 'rxjs';
import { tap } from 'rxjs/operators';
import { environment } from '../../../environments/environment';

export interface LoginRequest {
  email: string;
  password: string;
}

export interface RegisterRequest {
  email: string;
  password: string;
  firstName?: string;
  lastName?: string;
}

export interface RefreshRequest {
  token: string;
  refreshToken: string;
}

export interface AuthResponse {
  token: string;
  refreshToken: string;
}

@Injectable({
  providedIn: 'root'
})
export class AuthApiService {
    private baseUrl = environment.baseUrl + '/auth';



  constructor(private http: HttpClient) {}

  login(request: LoginRequest): Observable<AuthResponse> {
    return this.http.post<AuthResponse>(`${this.baseUrl}/login`, request).pipe(
      tap((response) => {
        if (response.token && response.refreshToken) {
          this.saveTokens(response.token, response.refreshToken);
        }
      })
    );
  }

  register(request: RegisterRequest): Observable<AuthResponse> {
    return this.http.post<AuthResponse>(`${this.baseUrl}/register`, request).pipe(
      tap((response) => {
        if (response.token && response.refreshToken) {
          this.saveTokens(response.token, response.refreshToken);
        }
      })
    );
  }

  refresh(request: RefreshRequest): Observable<AuthResponse> {
    return this.http.post<AuthResponse>(`${this.baseUrl}/refresh`, request).pipe(
      tap((response) => {
        if (response.token && response.refreshToken) {
          this.saveTokens(response.token, response.refreshToken);
        }
      })
    );
  }

  private saveTokens(token: string, refreshToken: string): void {
    localStorage.setItem('auth_token', token);
    localStorage.setItem('refresh_token', refreshToken);
  }

  getToken(): string | null {
    return localStorage.getItem('auth_token');
  }

  getRefreshToken(): string | null {
    return localStorage.getItem('refresh_token');
  }

  logout(): void {
    localStorage.removeItem('auth_token');
    localStorage.removeItem('refresh_token');
  }

  isAuthenticated(): boolean {
    return !!this.getToken();
  }
}

4. - Authentication + Interceptor
Create Interceptor
Path: "/src/app/core/interceptors/auth.interceptor.ts"

import { HttpInterceptorFn } from '@angular/common/http';
import { inject } from '@angular/core';
import { AuthApiService } from '../../app/services/api/auth.service';
import { Router } from '@angular/router';
import { catchError } from 'rxjs/operators';
import { throwError } from 'rxjs';

export const authInterceptor: HttpInterceptorFn = (req, next) => {
    const authService = inject(AuthApiService);
    const router = inject(Router);
    const token = authService.getToken();

    // Skip interceptor logic for auth endpoints (login, register, refresh)
    if (req.url.includes('/auth/login') || req.url.includes('/auth/register') || req.url.includes('/auth/refresh')) {
        return next(req).pipe(
            catchError((error) => {
                return throwError(() => error);
            })
        );
    }

    // If no token and trying to access protected routes, redirect to login
    if (!token) {
        router.navigate(['/auth/login']);
        return throwError(() => new Error('No authentication token found'));
    }

    // Clone request and add Authorization header with Bearer token
    req = req.clone({
        setHeaders: {
            Authorization: `Bearer ${token}`
        }
    });

    return next(req).pipe(
        catchError((error) => {
            // If 401 Unauthorized, clear localStorage and redirect to login
            if (error.status === 401) {
                authService.logout();
                router.navigate(['/auth/login']);
                return throwError(() => new Error('Session expired. Please login again.'));
            }
            return throwError(() => error);
        })
    );
};

5. - Move Login Component Features
Path: "/src/app/features/auth/login/login.html"
"/src/app/features/auth/login/login.scss" will be Blank file
"/src/app/features/auth/login/login.ts"
"/src/app/features/auth/auth.routes.ts"

login.html

<p-toast />
<app-floating-configurator />
<div class="bg-surface-50 dark:bg-surface-950 flex items-center justify-center min-h-screen min-w-screen overflow-hidden">
    <div class="flex flex-col items-center justify-center">
        <div style="border-radius: 56px; padding: 0.3rem; background: linear-gradient(180deg, var(--primary-color) 10%, rgba(33, 150, 243, 0) 30%)">
            <div class="w-full bg-surface-0 dark:bg-surface-900 py-20 px-8 sm:px-20" style="border-radius: 53px">
                <div class="text-center mb-8">
                    <svg viewBox="0 0 54 40" fill="none" xmlns="http://www.w3.org/2000/svg" class="mb-8 w-16 shrink-0 mx-auto">
                        <path
                            fill-rule="evenodd"
                            clip-rule="evenodd"
                            d="M17.1637 19.2467C17.1566 19.4033 17.1529 19.561 17.1529 19.7194C17.1529 25.3503 21.7203 29.915 27.3546 29.915C32.9887 29.915 37.5561 25.3503 37.5561 19.7194C37.5561 19.5572 37.5524 19.3959 37.5449 19.2355C38.5617 19.0801 39.5759 18.9013 40.5867 18.6994L40.6926 18.6782C40.7191 19.0218 40.7326 19.369 40.7326 19.7194C40.7326 27.1036 34.743 33.0896 27.3546 33.0896C19.966 33.0896 13.9765 27.1036 13.9765 19.7194C13.9765 19.374 13.9896 19.0316 14.0154 18.6927L14.0486 18.6994C15.0837 18.9062 16.1223 19.0886 17.1637 19.2467ZM33.3284 11.4538C31.6493 10.2396 29.5855 9.52381 27.3546 9.52381C25.1195 9.52381 23.0524 10.2421 21.3717 11.4603C20.0078 11.3232 18.6475 11.1387 17.2933 10.907C19.7453 8.11308 23.3438 6.34921 27.3546 6.34921C31.36 6.34921 34.9543 8.10844 37.4061 10.896C36.0521 11.1292 34.692 11.3152 33.3284 11.4538ZM43.826 18.0518C43.881 18.6003 43.9091 19.1566 43.9091 19.7194C43.9091 28.8568 36.4973 36.2642 27.3546 36.2642C18.2117 36.2642 10.8 28.8568 10.8 19.7194C10.8 19.1615 10.8276 18.61 10.8816 18.0663L7.75383 17.4411C7.66775 18.1886 7.62354 18.9488 7.62354 19.7194C7.62354 30.6102 16.4574 39.4388 27.3546 39.4388C38.2517 39.4388 47.0855 30.6102 47.0855 19.7194C47.0855 18.9439 47.0407 18.1789 46.9536 17.4267L43.826 18.0518ZM44.2613 9.54743L40.9084 10.2176C37.9134 5.95821 32.9593 3.1746 27.3546 3.1746C21.7442 3.1746 16.7856 5.96385 13.7915 10.2305L10.4399 9.56057C13.892 3.83178 20.1756 0 27.3546 0C34.5281 0 40.8075 3.82591 44.2613 9.54743Z"
                            fill="var(--primary-color)"
                        />
                        <mask id="mask0_1413_1551" style="mask-type: alpha" maskUnits="userSpaceOnUse" x="0" y="8" width="54" height="11">
                            <path d="M27 18.3652C10.5114 19.1944 0 8.88892 0 8.88892C0 8.88892 16.5176 14.5866 27 14.5866C37.4824 14.5866 54 8.88892 54 8.88892C54 8.88892 43.4886 17.5361 27 18.3652Z" fill="var(--primary-color)" />
                        </mask>
                        <g mask="url(#mask0_1413_1551)">
                            <path
                                d="M-4.673e-05 8.88887L3.73084 -1.91434L-8.00806 17.0473L-4.673e-05 8.88887ZM27 18.3652L26.4253 6.95109L27 18.3652ZM54 8.88887L61.2673 17.7127L50.2691 -1.91434L54 8.88887ZM-4.673e-05 8.88887C-8.00806 17.0473 -8.00469 17.0505 -8.00132 17.0538C-8.00018 17.055 -7.99675 17.0583 -7.9944 17.0607C-7.98963 17.0653 -7.98474 17.0701 -7.97966 17.075C-7.96949 17.0849 -7.95863 17.0955 -7.94707 17.1066C-7.92401 17.129 -7.89809 17.1539 -7.86944 17.1812C-7.8122 17.236 -7.74377 17.3005 -7.66436 17.3743C-7.50567 17.5218 -7.30269 17.7063 -7.05645 17.9221C-6.56467 18.3532 -5.89662 18.9125 -5.06089 19.5534C-3.39603 20.83 -1.02575 22.4605 1.98012 24.0457C7.97874 27.2091 16.7723 30.3226 27.5746 29.7793L26.4253 6.95109C20.7391 7.23699 16.0326 5.61231 12.6534 3.83024C10.9703 2.94267 9.68222 2.04866 8.86091 1.41888C8.45356 1.10653 8.17155 0.867278 8.0241 0.738027C7.95072 0.673671 7.91178 0.637576 7.90841 0.634492C7.90682 0.63298 7.91419 0.639805 7.93071 0.65557C7.93897 0.663455 7.94952 0.673589 7.96235 0.686039C7.96883 0.692262 7.97582 0.699075 7.98338 0.706471C7.98719 0.710167 7.99113 0.714014 7.99526 0.718014C7.99729 0.720008 8.00047 0.723119 8.00148 0.724116C8.00466 0.727265 8.00796 0.730446 -4.673e-05 8.88887ZM27.5746 29.7793C37.6904 29.2706 45.9416 26.3684 51.6602 23.6054C54.5296 22.2191 56.8064 20.8465 58.4186 19.7784C59.2265 19.2431 59.873 18.7805 60.3494 18.4257C60.5878 18.2482 60.7841 18.0971 60.9374 17.977C61.014 17.9169 61.0799 17.8645 61.1349 17.8203C61.1624 17.7981 61.1872 17.7781 61.2093 17.7602C61.2203 17.7512 61.2307 17.7427 61.2403 17.7348C61.2452 17.7308 61.2499 17.727 61.2544 17.7233C61.2566 17.7215 61.2598 17.7188 61.261 17.7179C61.2642 17.7153 61.2673 17.7127 54 8.88887C46.7326 0.0650536 46.7357 0.0625219 46.7387 0.0600241C46.7397 0.0592345 46.7427 0.0567658 46.7446 0.0551857C46.7485 0.0520238 46.7521 0.0489887 46.7557 0.0460799C46.7628 0.0402623 46.7694 0.0349487 46.7753 0.0301318C46.7871 0.0204986 46.7966 0.0128495 46.8037 0.00712562C46.818 -0.00431848 46.8228 -0.00808311 46.8184 -0.00463784C46.8096 0.00228345 46.764 0.0378652 46.6828 0.0983779C46.5199 0.219675 46.2165 0.439161 45.7812 0.727519C44.9072 1.30663 43.5257 2.14765 41.7061 3.02677C38.0469 4.79468 32.7981 6.63058 26.4253 6.95109L27.5746 29.7793ZM54 8.88887C50.2691 -1.91433 50.27 -1.91467 50.271 -1.91498C50.2712 -1.91506 50.272 -1.91535 50.2724 -1.9155C50.2733 -1.91581 50.274 -1.91602 50.2743 -1.91616C50.2752 -1.91643 50.275 -1.91636 50.2738 -1.91595C50.2714 -1.91515 50.2652 -1.91302 50.2552 -1.9096C50.2351 -1.90276 50.1999 -1.89078 50.1503 -1.874C50.0509 -1.84043 49.8938 -1.78773 49.6844 -1.71863C49.2652 -1.58031 48.6387 -1.377 47.8481 -1.13035C46.2609 -0.635237 44.0427 0.0249875 41.5325 0.6823C36.215 2.07471 30.6736 3.15796 27 3.15796V26.0151C33.8087 26.0151 41.7672 24.2495 47.3292 22.7931C50.2586 22.026 52.825 21.2618 54.6625 20.6886C55.5842 20.4011 56.33 20.1593 56.8551 19.986C57.1178 19.8993 57.3258 19.8296 57.4735 19.7797C57.5474 19.7548 57.6062 19.7348 57.6493 19.72C57.6709 19.7127 57.6885 19.7066 57.7021 19.7019C57.7089 19.6996 57.7147 19.6976 57.7195 19.696C57.7219 19.6952 57.7241 19.6944 57.726 19.6938C57.7269 19.6934 57.7281 19.693 57.7286 19.6929C57.7298 19.6924 57.7309 19.692 54 8.88887ZM27 3.15796C23.3263 3.15796 17.7849 2.07471 12.4674 0.6823C9.95717 0.0249875 7.73904 -0.635237 6.15184 -1.13035C5.36118 -1.377 4.73467 -1.58031 4.3155 -1.71863C4.10609 -1.78773 3.94899 -1.84043 3.84961 -1.874C3.79994 -1.89078 3.76474 -1.90276 3.74471 -1.9096C3.73469 -1.91302 3.72848 -1.91515 3.72613 -1.91595C3.72496 -1.91636 3.72476 -1.91643 3.72554 -1.91616C3.72593 -1.91602 3.72657 -1.91581 3.72745 -1.9155C3.72789 -1.91535 3.72874 -1.91506 3.72896 -1.91498C3.72987 -1.91467 3.73084 -1.91433 -4.673e-05 8.88887C-3.73093 19.692 -3.72983 19.6924 -3.72868 19.6929C-3.72821 19.693 -3.72698 19.6934 -3.72603 19.6938C-3.72415 19.6944 -3.72201 19.6952 -3.71961 19.696C-3.71482 19.6976 -3.70901 19.6996 -3.7022 19.7019C-3.68858 19.7066 -3.67095 19.7127 -3.6494 19.72C-3.60629 19.7348 -3.54745 19.7548 -3.47359 19.7797C-3.32589 19.8296 -3.11788 19.8993 -2.85516 19.986C-2.33008 20.1593 -1.58425 20.4011 -0.662589 20.6886C1.17485 21.2618 3.74125 22.026 6.67073 22.7931C12.2327 24.2495 20.1913 26.0151 27 26.0151V3.15796Z"
                                fill="var(--primary-color)"
                            />
                        </g>
                    </svg>
                    <div class="text-surface-900 dark:text-surface-0 text-3xl font-medium mb-4">Welcome to PrimeLand!</div>
                    <span class="text-muted-color font-medium">Sign in to continue</span>
                </div>

                <div>
                    <label for="email1" class="block text-surface-900 dark:text-surface-0 text-xl font-medium mb-2">Email</label>
                    <input pInputText id="email1" type="text" placeholder="Email address" class="w-full md:w-120 mb-8" [(ngModel)]="email" />

                    <label for="password1" class="block text-surface-900 dark:text-surface-0 font-medium text-xl mb-2">Password</label>
                    <p-password id="password1" [(ngModel)]="password" placeholder="Password" [toggleMask]="true" styleClass="mb-4" [fluid]="true" [feedback]="false"></p-password>

                    <div class="flex items-center justify-between mt-2 mb-8 gap-8">
                        <div class="flex items-center">
                            <p-checkbox [(ngModel)]="checked" id="rememberme1" binary class="mr-2"></p-checkbox>
                            <label for="rememberme1">Remember me</label>
                        </div>
                        <span class="font-medium no-underline ml-2 text-right cursor-pointer text-primary">Forgot password?</span>
                    </div>
                    <p-button label="Sign In" styleClass="w-full" (onClick)="handleLogin()" [loading]="isLoading"></p-button>
                </div>
            </div>
        </div>
    </div>
</div>

login.ts

import { Component } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { Router, RouterModule } from '@angular/router';
import { ButtonModule } from 'primeng/button';
import { CheckboxModule } from 'primeng/checkbox';
import { InputTextModule } from 'primeng/inputtext';
import { PasswordModule } from 'primeng/password';
import { RippleModule } from 'primeng/ripple';
import { AppFloatingConfigurator } from '../../../layout/component/app.floatingconfigurator';
import { AuthApiService } from '../../../services/api/auth.service';
import { MessageService } from 'primeng/api';
import { ToastModule } from 'primeng/toast';
import { CommonModule } from '@angular/common';

@Component({
    selector: 'app-login',
    standalone: true,
    imports: [
        CommonModule,
        ButtonModule,
        CheckboxModule,
        InputTextModule,
        PasswordModule,
        FormsModule,
        RouterModule,
        RippleModule,
        AppFloatingConfigurator,
        ToastModule
    ],
    providers: [MessageService],
    templateUrl: './login.html',
    styleUrl: './login.scss'
})
export class Login {
    email: string = '';
    password: string = '';
    checked: boolean = false;
    isLoading: boolean = false;

    constructor(
        private authApi: AuthApiService,
        private messageService: MessageService,
        private router: Router
    ) {}

    handleLogin() {
        if (!this.email || !this.password) {
            this.messageService.add({
                severity: 'warn',
                summary: 'Validation Error',
                detail: 'Email and password are required.',
                life: 3000
            });
            return;
        }

        this.isLoading = true;
        this.authApi.login({ email: this.email, password: this.password }).subscribe({
            next: (response: any) => {
                this.isLoading = false;
                this.messageService.add({
                    severity: 'success',
                    summary: 'Success',
                    detail: 'Login successful!',
                    life: 2000
                });
                // Redirect to dashboard after short delay
                setTimeout(() => {
                    this.router.navigate(['/dashboard']);
                }, 500);
            },
            error: (err: any) => {
                this.isLoading = false;
                const errorMsg = err.error?.errors?.[0] || 'Login failed. Please try again.';
                this.messageService.add({
                    severity: 'error',
                    summary: 'Login Failed',
                    detail: errorMsg,
                    life: 3000
                });
            }
        });
    }
}

auth.routes.ts

import { Routes } from '@angular/router';
import { Login } from './login/login';

export default [
    { path: '', redirectTo: 'login', pathMatch: 'full' },
    { path: 'login', component: Login }
] as Routes;

6. - Update App Routes
Path : "src/app/app.routes.ts"

import { Routes } from '@angular/router';
import { AppLayout } from './app/layout/component/app.layout';
import { Dashboard } from './app/pages/dashboard/dashboard';
import { Documentation } from './app/pages/documentation/documentation';
import { Landing } from './app/pages/landing/landing';
import { Notfound } from './app/pages/notfound/notfound';

export const appRoutes: Routes = [
    { 
        path: '', 
        redirectTo: () => {
            const token = localStorage.getItem('auth_token');
            return token ? '/dashboard' : '/auth/login';
        }, 
        pathMatch: 'full' 
    },
    {
        path: 'dashboard',
        component: AppLayout,
        children: [
            { path: '', component: Dashboard }
        ]
    },
    {
        path: 'uikit',
        component: AppLayout,
        children: [
            { path: '', loadChildren: () => import('./app/pages/uikit/uikit.routes') }
        ]
    },
    {
        path: 'pages',
        component: AppLayout,
        children: [
            { path: '', loadChildren: () => import('./app/pages/pages.routes') }
        ]
    },
    {
        path: 'documentation',
        component: AppLayout,
        children: [
            { path: '', component: Documentation }
        ]
    },
    { path: 'landing', component: Landing },
    { path: 'notfound', component: Notfound },
    { path: 'auth', loadChildren: () => import('./app/features/auth/auth.routes') },
    { path: '**', component: Notfound }
];

7. - Update App Config
Path: "src/app/app.config.ts"

import { provideHttpClient, withFetch, withInterceptors } from '@angular/common/http';
import { ApplicationConfig } from '@angular/core';
import { provideAnimationsAsync } from '@angular/platform-browser/animations/async';
import { provideRouter, withEnabledBlockingInitialNavigation, withInMemoryScrolling } from '@angular/router';
import Aura from '@primeuix/themes/aura';
import { providePrimeNG } from 'primeng/config';
import { appRoutes } from './app.routes';
import { authInterceptor } from '@/core/interceptors/auth.interceptor';



export const appConfig: ApplicationConfig = {
    providers: [
        provideRouter(appRoutes, withInMemoryScrolling({ anchorScrolling: 'enabled', scrollPositionRestoration: 'enabled' }), withEnabledBlockingInitialNavigation()),
        provideHttpClient(withFetch(), withInterceptors([authInterceptor])),
        provideAnimationsAsync(),
        providePrimeNG({ theme: { preset: Aura, options: { darkModeSelector: '.app-dark' } } })
    ]
};

8. - Lets Test

Install npm packages
npm i

After Installation Lets run both Application backend and angular
ng s -o

Click on Login

Next Lecture Preview
Lecture 9B : Product Management

Implementing product CRUD operations and connecting the frontend UI with backend APIs.

🧱 Lesson 8 - Authentication & Authorization in .NET

Farrukh Rehman — Tue, 18 Nov 2025 09:31:30 +0000

Source Code Backend : https://github.com/farrukh1212cs/ECommerce-Backend.git

Source Code Frontend : https://github.com/farrukh1212cs/ECommerce-Frontend.git

🎯 Introduction
add secure user authentication (JWT), role-based authorization. We'll use patterns that fit your Clean Architecture: interfaces in Application, implementations in Infrastructure, DI wiring in DependencyInjection, and usage in the API.

🔐 What you'll learn (brief)

JWT-based auth (register / login / issue token)
Role-based auth and policy-based authorization
Seeding admin/user roles
Protecting controllers/endpoints with [Authorize]
Refresh token strategy (overview + simple approach)
Optional: integrate Azure AD or IdentityServer (high-level steps)

📦 Packages to install

(choose versions compatible with .NET 8; run from solution root)

dotnet add ECommerce.Infrastructure package Microsoft.AspNetCore.Authentication.JwtBearer --version 8.0.21
dotnet add ECommerce.Infrastructure package Microsoft.AspNetCore.Identity.EntityFrameworkCore --version 8.0.21
dotnet add ECommerce.Domain package Microsoft.AspNetCore.Identity.EntityFrameworkCore --version 8.0.21
dotnet add ECommerce.Infrastructure package Microsoft.IdentityModel.Tokens
dotnet add ECommerce.Application package System.IdentityModel.Tokens.Jwt

🧱 High-level architecture

Identity stores (users/roles) live in your DB (via EF stores).
IAuthService in Application defines operations (Register, Login, Validate).
AuthService in Infrastructure implements token generation and uses UserManager/RoleManager.
Program.cs / DependencyInjection wires Identity + JwtBearer authentication + role seeding.

🔧 appsettings.json (JWT config example)

"JwtSettings": { "Issuer": "ECommerceApi", "Audience": "ECommerceClients", "Secret": "3A6DA077-8EBC-4DA9-94DF-2C246564E749", "ExpiresInMinutes": 60, "RefreshTokenExpiresInDays": 30 }

Keep Secret in secure store (Key Vault / environment variables) in production.

✅ Step 1 — Create Application User Entity
Path: ECommerce.Domain/Entities/ApplicationUser.cs

using Microsoft.AspNetCore.Identity;

namespace ECommerce.Domain.Entities;

public class ApplicationUser : IdentityUser<Guid>
{
    // Add extra properties if needed (FirstName, LastName)
    public string? FirstName { get; set; }
    public string? LastName { get; set; }
}

✅ Step 2 — Add Identity entities & DbContext

we already have AppDbContext derived from DbContext, extend it to use Identity:

using ECommerce.Domain.Entities;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore;

namespace ECommerce.Infrastructure.Data;

public abstract class AppDbContext : IdentityDbContext<ApplicationUser, IdentityRole<Guid>, Guid>
{
    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }

    // DbSets
    public DbSet<Product> Products { get; set; } = null!;
    public DbSet<Customer> Customers { get; set; } = null!;
    public DbSet<Order> Orders { get; set; } = null!;
    public DbSet<OrderItem> OrderItems { get; set; } = null!;
    public DbSet<ApplicationUser> ApplicationUser { get; set; } = null!;

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);

        // Product
        modelBuilder.Entity<Product>(b =>
        {
            b.ToTable("Products");
            b.HasKey(p => p.Id);
            b.Property(p => p.Name).IsRequired().HasMaxLength(200);
            b.Property(p => p.Price).HasColumnType("decimal(18,2)");
        });

        // Customer
        modelBuilder.Entity<Customer>(b =>
        {
            b.ToTable("Customers");
            b.HasKey(c => c.Id);
            b.Property(c => c.FirstName).IsRequired().HasMaxLength(200);
            b.Property(c => c.Email).IsRequired().HasMaxLength(256);
            b.HasMany(c => c.Orders)
             .WithOne(o => o.Customer)
             .HasForeignKey(o => o.CustomerId)
             .OnDelete(DeleteBehavior.Cascade);
        });

        // Order
        modelBuilder.Entity<Order>(b =>
        {
            b.ToTable("Orders");
            b.HasKey(o => o.Id);
            b.Property(o => o.OrderDate).IsRequired();
            b.Property(o => o.TotalAmount).HasColumnType("decimal(18,2)");
            b.HasMany(o => o.Items)
             .WithOne(oi => oi.Order)
             .HasForeignKey(oi => oi.OrderId)
             .OnDelete(DeleteBehavior.Cascade);
        });

        // OrderItem
        modelBuilder.Entity<OrderItem>(b =>
        {
            b.ToTable("OrderItems");
            b.HasKey(oi => oi.Id);
            b.Property(oi => oi.ProductName).IsRequired().HasMaxLength(200);
            b.Property(oi => oi.UnitPrice).HasColumnType("decimal(18,2)");
            b.Property(oi => oi.Quantity).IsRequired();
        });

        // If you want to seed or add indexes later, do it here.
    }
}

✅ Step 3 — Define IAuthService (Application layer)
Path: ECommerce.Application/Services/Interfaces/IAuthService.cs

namespace ECommerce.Application.Services.Interfaces;

public interface IAuthService
{
    Task<AuthenticationResult> RegisterAsync(RegisterRequest request);
    Task<AuthenticationResult> LoginAsync(LoginRequest request);
    Task<AuthenticationResult> RefreshTokenAsync(string token, string refreshToken);
}

public record RegisterRequest(string Email, string Password, string? FirstName = null, string? LastName = null);
public record LoginRequest(string Email, string Password);
public record AuthenticationResult(bool Success, string? Token, string? RefreshToken, IEnumerable<string>? Errors);
public record RefreshRequest(string Token, string RefreshToken);

✅ Step 4 — Implement AuthService (Infrastructure)
Path: ECommerce.Application/Services/Implementations/AuthService.cs

using ECommerce.Application.Services.Interfaces;
using ECommerce.Domain.Entities;
using Microsoft.AspNetCore.Identity;
using Microsoft.Extensions.Configuration;
using Microsoft.IdentityModel.Tokens;
using System;
using System.Collections.Generic;
using System.IdentityModel.Tokens.Jwt;
using System.Linq;
using System.Security.Claims;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;

namespace ECommerce.Application.Services.Implementations;

public class AuthService : IAuthService
{
    private readonly UserManager<ApplicationUser> _userManager;
    private readonly IConfiguration _config;
    private readonly RoleManager<IdentityRole<Guid>> _roleManager;

    public AuthService(UserManager<ApplicationUser> userManager, RoleManager<IdentityRole<Guid>> roleManager, IConfiguration config)
    {
        _userManager = userManager;
        _roleManager = roleManager;
        _config = config;
    }

    public async Task<AuthenticationResult> RegisterAsync(RegisterRequest request)
    {
        var existing = await _userManager.FindByEmailAsync(request.Email);
        if (existing != null)
            return new AuthenticationResult(false, null, null, new[] { "User already exists" });

        var user = new ApplicationUser { Email = request.Email, UserName = request.Email, FirstName = request.FirstName, LastName = request.LastName };
        var result = await _userManager.CreateAsync(user, request.Password);
        if (!result.Succeeded)
            return new AuthenticationResult(false, null, null, result.Errors.Select(e => e.Description));

        // Optionally add default role
        await _userManager.AddToRoleAsync(user, "User");

        // generate tokens
        var token = await GenerateJwtToken(user);
        var refreshToken = GenerateRefreshToken(); // implement secure random token and store it

        // persist refresh token with user (e.g., in DB)
        // ...

        return new AuthenticationResult(true, token, refreshToken, null);
    }

    public async Task<AuthenticationResult> LoginAsync(LoginRequest request)
    {
        var user = await _userManager.FindByEmailAsync(request.Email);
        if (user == null) return new AuthenticationResult(false, null, null, new[] { "Invalid credentials" });

        if (!await _userManager.CheckPasswordAsync(user, request.Password))
            return new AuthenticationResult(false, null, null, new[] { "Invalid credentials" });

        var token = await GenerateJwtToken(user);
        var refreshToken = GenerateRefreshToken();
        // store refresh token...

        return new AuthenticationResult(true, token, refreshToken, null);
    }

    public Task<AuthenticationResult> RefreshTokenAsync(string token, string refreshToken)
    {
        // validate existing refresh token stored in DB, expiration, rotation, etc.
        throw new NotImplementedException();
    }

    private async Task<string> GenerateJwtToken(ApplicationUser user)
    {
        var jwt = _config.GetSection("JwtSettings");
        var secret = jwt["Secret"]!;
        var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(secret));
        var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);

        var claims = new List<Claim>
        {
            new Claim(JwtRegisteredClaimNames.Sub, user.Id.ToString()),
            new Claim(JwtRegisteredClaimNames.Email, user.Email!),
            new Claim(ClaimTypes.Name, user.UserName!)
        };

        var userRoles = await _userManager.GetRolesAsync(user);
        claims.AddRange(userRoles.Select(r => new Claim(ClaimTypes.Role, r)));

        var token = new JwtSecurityToken(
            issuer: jwt["Issuer"],
            audience: jwt["Audience"],
            claims: claims,
            expires: DateTime.UtcNow.AddMinutes(double.Parse(jwt["ExpiresInMinutes"] ?? "60")),
            signingCredentials: creds);

        return new JwtSecurityTokenHandler().WriteToken(token);
    }

    private static string GenerateRefreshToken()
    {
        return Convert.ToBase64String(RandomNumberGenerator.GetBytes(64));
    }
}

✅ Step 5 — Wire up Identity, JwtBearer and DI

using ECommerce.API.BackgroundServices;
using ECommerce.Application.Services.Interfaces;
using ECommerce.Infrastructure.Caching;
using ECommerce.Infrastructure.Data;
using ECommerce.Infrastructure.Email;
using ECommerce.Infrastructure.Messaging;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.IdentityModel.Tokens;
using StackExchange.Redis;
using System.Text;



namespace ECommerce.Infrastructure;

public static class DependencyInjection
{
    public static IServiceCollection AddInfrastructure(
        this IServiceCollection services,
        IConfiguration configuration)
    {

        var provider = configuration["DatabaseProvider"] ?? "MySQL";

        if (string.Equals(provider, "SqlServer", StringComparison.OrdinalIgnoreCase))
        {
            var conn = configuration.GetConnectionString("SqlServer");
            services.AddDbContext<AppDbContext, SqlServerDbContext>(options =>
                options.UseSqlServer(conn));
        }
        else if (string.Equals(provider, "MySQL", StringComparison.OrdinalIgnoreCase))
        {
            var conn = configuration.GetConnectionString("MySQL");
            services.AddDbContext<AppDbContext, MySqlDbContext>(options =>
                options.UseMySql(conn, ServerVersion.AutoDetect(conn)));
        }
        else if (string.Equals(provider, "PostgreSQL", StringComparison.OrdinalIgnoreCase))
        {

            var conn = configuration.GetConnectionString("PostgreSQL");
            services.AddDbContext<AppDbContext, PostgresDbContext>(options =>
                options.UseNpgsql(conn));
        }
        else
        {
            throw new InvalidOperationException($"Unsupported provider: {provider}");
        }

        // ✅ Add Identity
        services.AddIdentity<IdentityUser, IdentityRole>()
            .AddEntityFrameworkStores<AppDbContext>()
            .AddDefaultTokenProviders();

        // ✅ JWT Authentication setup
        var jwtSettings = configuration.GetSection("JwtSettings");
        var key = Encoding.UTF8.GetBytes(jwtSettings["Secret"]);

        services.AddAuthentication(options =>
        {
            options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
            options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
        })
           .AddJwtBearer(options =>
           {
               options.RequireHttpsMetadata = false;
               options.SaveToken = true;
               options.TokenValidationParameters = new TokenValidationParameters
               {
                   ValidateIssuer = true,
                   ValidateAudience = true,
                   ValidateLifetime = true,
                   ValidateIssuerSigningKey = true,
                   ValidIssuer = jwtSettings["Issuer"],
                   ValidAudience = jwtSettings["Audience"],
                   IssuerSigningKey = new SymmetricSecurityKey(key)
               };
           });

        // ✅ Authorization
        services.AddAuthorization(options =>
        {
            options.AddPolicy("AdminOnly", policy => policy.RequireRole("Admin"));
            options.AddPolicy("CustomerOnly", policy => policy.RequireRole("Customer"));
        });

        // ✅ Redis cache setup
        var redisConnection = configuration.GetConnectionString("Redis");
        if (!string.IsNullOrEmpty(redisConnection))
        {
            services.AddSingleton<IConnectionMultiplexer>(sp =>
                ConnectionMultiplexer.Connect(redisConnection));

            services.AddSingleton<ICacheService, RedisCacheService>();
        }

        // RabbitMQ setup
        services.AddSingleton<IMessageQueueService, RabbitMQService>();
        services.AddScoped<IEmailSenderService, EmailSenderService>();


        return services;
    }
}

✅ Step 6 — Update Program.cs

app.UseAuthentication();
app.UseAuthorization();

✅ Step 7 — Seed roles and an admin user
Path: ECommerce.Infrastructure/Identity/IdentitySeeder.cs

using ECommerce.Domain.Entities;
using Microsoft.AspNetCore.Identity;
using Microsoft.Extensions.DependencyInjection;
using System;
using System.Threading.Tasks;

namespace ECommerce.Infrastructure.Identity
{
    public static class IdentitySeeder
    {
        public static async Task SeedRolesAndAdminAsync(IServiceProvider serviceProvider)
        {
            // Use the correct types matching your Identity setup
            var roleManager = serviceProvider.GetRequiredService<RoleManager<IdentityRole<Guid>>>();
            var userManager = serviceProvider.GetRequiredService<UserManager<ApplicationUser>>();

            string[] roles = { "Admin", "Customer" };

            // Ensure roles exist
            foreach (var role in roles)
            {
                if (!await roleManager.RoleExistsAsync(role))
                {
                    await roleManager.CreateAsync(new IdentityRole<Guid>(role));
                }
            }

            // Create default admin user if missing
            var adminEmail = "admin@ecommerce.com";
            var adminUser = await userManager.FindByEmailAsync(adminEmail);
            if (adminUser == null)
            {
                adminUser = new ApplicationUser
                {
                    UserName = adminEmail,
                    Email = adminEmail,
                    EmailConfirmed = true
                };

                var result = await userManager.CreateAsync(adminUser, "Admin@123");

                if (result.Succeeded)
                {
                    await userManager.AddToRoleAsync(adminUser, "Admin");
                }
            }
        }
    }
}

✅ Step 8 — Add the Above Seeting in Program.cs

using (var scope = app.Services.CreateScope())
{
    var services = scope.ServiceProvider;
    await IdentitySeeder.SeedRolesAndAdminAsync(services);
}

✅ Step 9 — Lets Create Migrations for All DBs

dotnet ef migrations add IdentityMySQL -p ECommerce.Infrastructure -s ECommerce.API --context MySqlDbContext --output-dir "Migrations/MySQL"

dotnet ef migrations add IdentitySqlServer -p ECommerce.Infrastructure -s ECommerce.API --context SqlServerDbContext --output-dir "Migrations/SqlServer"

dotnet ef migrations add IdentityPostgreSQL -p ECommerce.Infrastructure -s ECommerce.API --context PostgresDbContext --output-dir "Migrations/PostgreSQL"

✅ Step 10 — Update DB

dotnet ef database update -p ECommerce.Infrastructure -s ECommerce.API --context MySqlDbContext 
dotnet ef database update -p ECommerce.Infrastructure -s ECommerce.API --context SqlServerDbContext 
dotnet ef database update -p ECommerce.Infrastructure -s ECommerce.API --context PostgresDbContext

✅ Step 10 — Let Run and Seed Data

Seedind Done

Verify Data in DB

✅ Step 11 — Register IAuthService in DependencyInjection.cs

services.AddScoped<IAuthService, AuthService>();

✅ Step 12 — Create Auth Controller

using ECommerce.Application.Services.Interfaces;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;


namespace ECommerce.API.Controllers;

[Authorize]
[Route("api/[controller]")]
[ApiController]
public class AuthController : ControllerBase
{
    private readonly IAuthService _auth;
    public AuthController(IAuthService auth) => _auth = auth;

    [HttpPost("register")]
    public async Task<IActionResult> Register(Application.Services.Interfaces.RegisterRequest req)
    {
        var res = await _auth.RegisterAsync(req);
        if (!res.Success) return BadRequest(res.Errors);
        return Ok(new { token = res.Token, refreshToken = res.RefreshToken });
    }
    [AllowAnonymous]
    [HttpPost("login")]
    public async Task<IActionResult> Login(Application.Services.Interfaces.LoginRequest req)
    {
        var res = await _auth.LoginAsync(req);
        if (!res.Success) return Unauthorized(res.Errors);
        return Ok(new { token = res.Token, refreshToken = res.RefreshToken });
    }

    [HttpPost("refresh")]
    public async Task<IActionResult> Refresh(Application.Services.Interfaces.RefreshRequest req)
    {
        var res = await _auth.RefreshTokenAsync(req.Token, req.RefreshToken);
        if (!res.Success) return Unauthorized(res.Errors);
        return Ok(new { token = res.Token, refreshToken = res.RefreshToken });
    }
}

✅ Step 13 — Lets Work on CORS for Angular

Update Program file, Add Core Configurations after swagger Step 1

// ------------------------------------------------------
// CORS
// ------------------------------------------------------
var allowedOrigins = builder.Configuration.GetSection("Cors:AllowedOrigins").Get<string[]>();

builder.Services.AddCors(options =>
{
    options.AddPolicy("AllowFrontend", policy =>
    {
        policy.WithOrigins(allowedOrigins!)
              .AllowAnyHeader()
              .AllowAnyMethod()
              .AllowCredentials();
    });
});

Step 2
Use Cors after Redirection

app.UseCors("AllowFrontend");

✅ Step 14 — Update appsettings.json

"Cors": {
  "AllowedOrigins": [
    "http://localhost:4200",
    "https://localhost:4200"
  ]
}

✅ Step 15 — Configure Auth Settings in Swagger
Update in Programfile, Replace builder.Services.AddSwaggerGen() with below code

builder.Services.AddSwaggerGen(c =>
{
    c.SwaggerDoc("v1", new() { Title = "ECommerce API", Version = "v1" });

    // Add JWT Authentication to Swagger
    c.AddSecurityDefinition("Bearer", new Microsoft.OpenApi.Models.OpenApiSecurityScheme
    {
        Name = "Authorization",
        Type = Microsoft.OpenApi.Models.SecuritySchemeType.Http,
        Scheme = "Bearer",
        BearerFormat = "JWT",
        In = Microsoft.OpenApi.Models.ParameterLocation.Header,
        Description = "Enter JWT token: Bearer {your token}"
    });

    c.AddSecurityRequirement(new Microsoft.OpenApi.Models.OpenApiSecurityRequirement
    {
        {
            new Microsoft.OpenApi.Models.OpenApiSecurityScheme
            {
                Reference = new Microsoft.OpenApi.Models.OpenApiReference
                {
                    Type = Microsoft.OpenApi.Models.ReferenceType.SecurityScheme,
                    Id = "Bearer"
                }
            },
            new string[] {}
        }
    });
});

✅ Step 16 — Lets Auth Test Application

✅ Step 17 — Lets Product Controller

Add Token

Next Lecture Preview
Lecture 9A : Login Frontend Integration

Creating login pages, implementing HTTP interceptors, error handling, and integrating frontend with backend authentication APIs.

🧱 Lesson 7 - Message Queues with RabbitMQ

Farrukh Rehman — Mon, 10 Nov 2025 15:15:52 +0000

Source Code Backend : https://github.com/farrukh1212cs/ECommerce-Backend.git

Source Code Frontend : https://github.com/farrukh1212cs/ECommerce-Frontend.git

🎯 Introduction

In a modern microservices or modular system, asynchronous processing is key to maintaining performance and scalability.
Imagine your application needs to send an email every time a user registers or a new product is added.
If you perform this action synchronously inside the request pipeline, your API will slow down and block other requests.

That’s where RabbitMQ — a message broker — comes in.
It allows you to publish messages (like “Send this email”) into a queue, which can later be consumed by a background service that actually sends the email.

This decouples your API logic from long-running or slow tasks.

🐇 Step 1 — Pull RabbitMQ Docker Image

Run the following command to pull and start RabbitMQ (with management dashboard):

docker run -d --hostname rabbitmq-host --name rabbitmq -p 5672:5672 -p 15672:15672 rabbitmq:3-management

✅ Ports Explanation:

5672 → for app communication
15672 → for web dashboard (management UI)

Then open your browser and visit:
👉 http://localhost:15672

Default credentials:
Username: guest | Password: guest

⚙️ Step 2 — Install NuGet Package

In the Infrastructure project, install the official RabbitMQ client library:

dotnet add ECommerce.Infrastructure package RabbitMQ.Client --version 6.8.1
dotnet add ECommerce.Infrastructure package Microsoft.Extensions.Configuration.Binder
dotnet add ECommerce.Infrastructure package Microsoft.Extensions.Hosting --version 8.0.1

🧩 Step 3 — Create Message Queue Interface
Path: ECommerce.Application/Services/Interfaces/IMessageQueueService.cs

namespace ECommerce.Application.Services.Interfaces;

public interface IMessageQueueService
{
    Task PublishAsync<T>(string queueName, T message);
    void Subscribe<T>(string queueName, Func<T, Task> handler);
}

This defines a simple contract for publishing and consuming messages.

⚙️ Step 4 — Implement RabbitMQ Service
Path: ECommerce.Infrastructure/Messaging/RabbitMQService.cs

using ECommerce.Application.Services.Interfaces;
using Microsoft.Extensions.Configuration;
using RabbitMQ.Client;
using RabbitMQ.Client.Events;
using System.Text;
using System.Text.Json;

namespace ECommerce.Infrastructure.Messaging;

public class RabbitMQService : IMessageQueueService, IDisposable
{
    private readonly IConnection _connection;
    private readonly RabbitMQ.Client.IModel _channel;

    public RabbitMQService(IConfiguration configuration)
    {
        var factory = new ConnectionFactory
        {
            HostName = configuration.GetValue<string>("RabbitMQ:Host") ?? "localhost",
            UserName = configuration.GetValue<string>("RabbitMQ:Username") ?? "guest",
            Password = configuration.GetValue<string>("RabbitMQ:Password") ?? "guest",
            Port = configuration.GetValue<int?>("RabbitMQ:Port") ?? 5672
        };

        _connection = factory.CreateConnection();
        _channel = _connection.CreateModel();
    }

    public Task PublishAsync<T>(string queueName, T message)
    {
        _channel.QueueDeclare(queueName, durable: true, exclusive: false, autoDelete: false);

        var body = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(message));
        _channel.BasicPublish("", queueName, null, body);

        Console.WriteLine($"📤 Published message to queue '{queueName}'");
        return Task.CompletedTask;
    }

    public void Subscribe<T>(string queueName, Func<T, Task> handler)
    {
        _channel.QueueDeclare(queueName, durable: true, exclusive: false, autoDelete: false);

        var consumer = new EventingBasicConsumer(_channel);
        consumer.Received += async (sender, ea) =>
        {
            var body = ea.Body.ToArray();
            var message = JsonSerializer.Deserialize<T>(Encoding.UTF8.GetString(body));
            if (message != null)
                await handler(message);
        };

        _channel.BasicConsume(queueName, autoAck: true, consumer: consumer);
        Console.WriteLine($"📥 Subscribed to queue '{queueName}'");
    }

    public void Dispose()
    {
        _channel?.Dispose();
        _connection?.Dispose();
    }
}

🧱 Step 5 — Add Configuration in appsettings.json (we will use ethereal.email for testing)

"RabbitMQ": { "Host": "localhost", "Port": 5672, "Username": "guest", "Password": "guest" }, "SmtpSettings": { "Host": "smtp.ethereal.email", "Port": 587, "Username": "alize.hilpert67@ethereal.email", "Password": "E4GnEsxZGbrc1XcS7q", "EnableSsl": true, "From": "no-reply@ecommerce.com" }

📧 Step 6 — Email Notification DTO
Path: ECommerce.Application/DTOs/EmailNotificationDto.cs

namespace ECommerce.Application.DTOs;

public class EmailNotificationDto
{
    public string To { get; set; } = string.Empty;
    public string Subject { get; set; } = string.Empty;
    public string Body { get; set; } = string.Empty;
}

🧱 Step 7 — Add Interface for Email Sender
Path: ECommerce.Application/Services/Interfaces/IEmailSenderService.cs

using ECommerce.Application.DTOs;

namespace ECommerce.Application.Services.Interfaces;

public interface IEmailSenderService
{
    Task SendEmailAsync(EmailNotificationDto email);
}

📬 Step 8 — Email Sender Service
Path: ECommerce.Infrastructure/Email/EmailSenderService.cs

using ECommerce.Application.DTOs;
using ECommerce.Application.Services.Interfaces;
using Microsoft.Extensions.Configuration;
using System.Net;
using System.Net.Mail;

namespace ECommerce.Infrastructure.Email;

public class EmailSenderService : IEmailSenderService
{
    private readonly IConfiguration _config;

    public EmailSenderService(IConfiguration config)
    {
        _config = config;
    }

    public async Task SendEmailAsync(EmailNotificationDto email)
    {
        var smtp = _config.GetSection("SmtpSettings");

        using var client = new SmtpClient(smtp["Host"], int.Parse(smtp["Port"] ?? "587"))
        {
            Credentials = new NetworkCredential(smtp["Username"], smtp["Password"]),
            EnableSsl = bool.Parse(smtp["EnableSsl"] ?? "true")
        };

        var message = new MailMessage
        {
            From = new MailAddress(smtp["From"] ?? smtp["Username"]),
            Subject = email.Subject,
            Body = email.Body,
            IsBodyHtml = true
        };
        message.To.Add(email.To);

        await client.SendMailAsync(message);
        Console.WriteLine($"📨 Email sent to {email.To}");
    }
}

🧩 Step 9 — Background Worker to Consume Email Queue
Path: ECommerce.API/BackgroundServices/EmailNotificationConsumer.cs

using ECommerce.Application.DTOs;
using ECommerce.Application.Services.Interfaces;

namespace ECommerce.API.BackgroundServices;

public class EmailNotificationConsumer : BackgroundService
{
    private readonly IMessageQueueService _queue;
    private readonly IEmailSenderService _emailSender;

    public EmailNotificationConsumer(IMessageQueueService queue, IEmailSenderService emailSender)
    {
        _queue = queue;
        _emailSender = emailSender;
    }

    protected override Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _queue.Subscribe<EmailNotificationDto>("email_notifications", async email =>
        {
            Console.WriteLine($"📧 Sending email to: {email.To}");
            await _emailSender.SendEmailAsync(email);
        });

        return Task.CompletedTask;
    }
}

🧩 Step 10 — Register Everything DependencyInjection.cs
Path: ECommerce.Infrastructure/DependencyInjection.cs

using ECommerce.API.BackgroundServices;
using ECommerce.Application.Services.Interfaces;
using ECommerce.Infrastructure.Caching;
using ECommerce.Infrastructure.Data;
using ECommerce.Infrastructure.Email;
using ECommerce.Infrastructure.Messaging;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using StackExchange.Redis;



namespace ECommerce.Infrastructure;

public static class DependencyInjection
{
    public static IServiceCollection AddInfrastructure(
        this IServiceCollection services,
        IConfiguration configuration)
    {
        var provider = configuration["DatabaseProvider"] ?? "MySQL";

        if (string.Equals(provider, "SqlServer", StringComparison.OrdinalIgnoreCase))
        {
            var conn = configuration.GetConnectionString("SqlServer");
            services.AddDbContext<AppDbContext, SqlServerDbContext>(options =>
                options.UseSqlServer(conn));
        }
        else if (string.Equals(provider, "MySQL", StringComparison.OrdinalIgnoreCase))
        {
            var conn = configuration.GetConnectionString("MySQL");
            services.AddDbContext<AppDbContext, MySqlDbContext>(options =>
                options.UseMySql(conn, ServerVersion.AutoDetect(conn)));
        }
        else if (string.Equals(provider, "PostgreSQL", StringComparison.OrdinalIgnoreCase))
        {

            var conn = configuration.GetConnectionString("PostgreSQL");
            services.AddDbContext<AppDbContext, PostgresDbContext>(options =>
                options.UseNpgsql(conn));
        }
        else
        {
            throw new InvalidOperationException($"Unsupported provider: {provider}");
        }

        // ✅ Redis cache setup
        var redisConnection = configuration.GetConnectionString("Redis");
        if (!string.IsNullOrEmpty(redisConnection))
        {
            services.AddSingleton<IConnectionMultiplexer>(sp =>
                ConnectionMultiplexer.Connect(redisConnection));

            services.AddSingleton<ICacheService, RedisCacheService>();
        }

        // RabbitMQ setup
        services.AddSingleton<IMessageQueueService, RabbitMQService>();
        services.AddScoped<IEmailSenderService, EmailSenderService>();

        return services;
    }
}

🧩 Step 11 — Update Program.cs
Path: ECommerce.API/Program.cs

// add infrastructure (DbContext + provider selection)
builder.Services.AddInfrastructure(builder.Configuration);

builder.Services.AddHostedService<EmailNotificationConsumer>();

🧩 Step 12 — Lets Test

Try Using Swagger

Backend Code

RabbitMQ

Consumer

RabbitMQ Service

Email

Next Lecture Preview
Lecture 8 : Authentication & Authorization in .NET

Implementing JWT-based authentication, role-based authorization, and optional Azure AD/IdentityServer integration.

🧱 Lesson 6 - Redis Caching for Performance Optimization

Farrukh Rehman — Wed, 05 Nov 2025 13:44:19 +0000

Source Code Backend : https://github.com/farrukh1212cs/ECommerce-Backend.git

Source Code Frontend : https://github.com/farrukh1212cs/ECommerce-Frontend.git

🎯 Introduction

In modern e-commerce applications, performance is critical — users expect fast responses, low latency, and instant data access.
One of the most effective ways to achieve this is by introducing caching.

In this lesson, we’ll integrate Redis, an in-memory data store, to cache frequently accessed data (like products, categories, and user sessions) and reduce database load.

Redis helps you:

Decrease response times ⚡
Reduce the number of database calls 📉
Handle high traffic efficiently 🚀

By the end of this lesson, your e-commerce system will have a working Redis integration ready for caching services.

🧩 Step 1: Pull Redis Docker Image

Let’s begin by setting up Redis locally using Docker.
Run the following command in your terminal:

docker pull redis:latest

Once the image is downloaded, start the Redis container:

docker run --name ecommerce-redis -p 6379:6379 -d redis

You can verify that Redis is running using:

docker ps

⚙️ Step 2: Install Redis Package

In your ECommerce.Infrastructure project, install the official Redis client for .NET — StackExchange.Redis.

dotnet add ECommerce.Infrastructure package StackExchange.Redis

🧠 Step 3: Configure Redis in appsettings.json
Add your Redis connection string:

 "DatabaseProvider": "PostgreSQL",
 "ConnectionStrings": {
   "PostgreSQL": "Host=localhost;Port=5432;Database=ECommerceDb;Username=postgres;Password=Admin123!",
   "MySQL": "Server=localhost;Port=3306;Database=ECommerceDb;User=root;Password=Admin123!;",
   "SqlServer": "Server=localhost,1433;Database=ECommerceDb;User Id=sa;Password=Admin123!;TrustServerCertificate=True;",
   "Redis": "localhost:6379"
 }

🧩 Step 4 : Create Interface ICacheService.cs
Path : ECommerce.Application/Services/Interfaces/ICacheService.cs

namespace ECommerce.Application.Services.Interfaces;

public interface ICacheService
{
    Task SetAsync<T>(string key, T value, TimeSpan? expiry = null);
    Task<T?> GetAsync<T>(string key);
    Task RemoveAsync(string key);
}

✅ Purpose:

Defines a simple contract for caching.
Keeps Redis implementation hidden behind the interface.
Allows you to switch to another caching provider (e.g., MemoryCache, DistributedCache) in the future.

⚙️ Step 5 : Implement the Interface in RedisCacheService.cs
Path : ECommerce.Infrastructure/Caching/RedisCacheService.cs

using ECommerce.Application.Services.Interfaces;
using StackExchange.Redis;
using System.Text.Json;

namespace ECommerce.Infrastructure.Caching;

public class RedisCacheService : ICacheService
{
    private readonly IDatabase _database;

    public RedisCacheService(IConnectionMultiplexer redis)
    {
        _database = redis.GetDatabase();
    }

    public async Task SetAsync<T>(string key, T value, TimeSpan? expiry = null)
    {
        var json = JsonSerializer.Serialize(value);
        await _database.StringSetAsync(key, json, expiry);
    }

    public async Task<T?> GetAsync<T>(string key)
    {
        var value = await _database.StringGetAsync(key);
        return value.IsNullOrEmpty ? default : JsonSerializer.Deserialize<T>(value!);
    }

    public async Task RemoveAsync(string key)
    {
        await _database.KeyDeleteAsync(key);
    }
}

✅ Step 6 : Updated DependencyInjection.cs

using ECommerce.Application.Services.Interfaces;
using ECommerce.Infrastructure.Caching;
using ECommerce.Infrastructure.Data;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using StackExchange.Redis;

namespace ECommerce.Infrastructure;

public static class DependencyInjection
{
    public static IServiceCollection AddInfrastructure(
        this IServiceCollection services,
        IConfiguration configuration)
    {
        var provider = configuration["DatabaseProvider"] ?? "MySQL";

        if (string.Equals(provider, "SqlServer", StringComparison.OrdinalIgnoreCase))
        {
            var conn = configuration.GetConnectionString("SqlServer");
            services.AddDbContext<AppDbContext, SqlServerDbContext>(options =>
                options.UseSqlServer(conn));
        }
        else if (string.Equals(provider, "MySQL", StringComparison.OrdinalIgnoreCase))
        {
            var conn = configuration.GetConnectionString("MySQL");
            services.AddDbContext<AppDbContext, MySqlDbContext>(options =>
                options.UseMySql(conn, ServerVersion.AutoDetect(conn)));
        }
        else if (string.Equals(provider, "PostgreSQL", StringComparison.OrdinalIgnoreCase))
        {

            var conn = configuration.GetConnectionString("PostgreSQL");
            services.AddDbContext<AppDbContext, PostgresDbContext>(options =>
                options.UseNpgsql(conn));
        }
        else
        {
            throw new InvalidOperationException($"Unsupported provider: {provider}");
        }

        // ✅ Redis cache setup
        var redisConnection = configuration.GetConnectionString("Redis");
        if (!string.IsNullOrEmpty(redisConnection))
        {
            services.AddSingleton<IConnectionMultiplexer>(sp =>
                ConnectionMultiplexer.Connect(redisConnection));

            services.AddSingleton<ICacheService, RedisCacheService>();
        }

        return services;
    }
}

✅ Step 7 : Updated ProductsController with Redis Cache Support

using ECommerce.Application.DTOs;
using ECommerce.Application.Services.Interfaces;
using Microsoft.AspNetCore.Mvc;

namespace ECommerce.API.Controllers;

[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    private readonly IProductService _productService;
    private readonly ICacheService _cacheService;

    public ProductsController(IProductService productService, ICacheService cacheService)
    {
        _productService = productService;
        _cacheService = cacheService;
    }

    [HttpGet]
    public async Task<ActionResult<IEnumerable<ProductDto>>> GetAll()
    {
        const string cacheKey = "products:all";

        // Try get from cache
        var cachedProducts = await _cacheService.GetAsync<IEnumerable<ProductDto>>(cacheKey);
        if (cachedProducts != null)
        {
            return Ok(new
            {
                fromCache = true,
                data = cachedProducts
            });
        }

        // Get from DB if not cached
        var products = await _productService.GetAllAsync();

        // Cache for 60 minutes
        await _cacheService.SetAsync(cacheKey, products, TimeSpan.FromMinutes(60));

        return Ok(new
        {
            fromCache = false,
            data = products
        });
    }

    [HttpGet("{id}")]
    public async Task<ActionResult<ProductDto>> GetById(Guid id)
    {
        var cacheKey = $"product:{id}";

        // Check cache
        var cachedProduct = await _cacheService.GetAsync<ProductDto>(cacheKey);
        if (cachedProduct != null)
        {
            return Ok(new
            {
                fromCache = true,
                data = cachedProduct
            });
        }

        // Fetch from service
        var product = await _productService.GetByIdAsync(id);
        if (product == null)
            return NotFound();

        // Cache for 60 minutes
        await _cacheService.SetAsync(cacheKey, product, TimeSpan.FromMinutes(60));

        return Ok(new
        {
            fromCache = false,
            data = product
        });
    }

    [HttpPost]
    public async Task<ActionResult> Create(ProductDto dto)
    {
        await _productService.AddAsync(dto);

        // Invalidate cache
        await _cacheService.RemoveAsync("products:all");

        return CreatedAtAction(nameof(GetById), new { id = dto.Id }, dto);
    }

    [HttpPut("{id}")]
    public async Task<ActionResult> Update(Guid id, ProductDto dto)
    {
        if (id != dto.Id)
            return BadRequest("Mismatched product ID.");

        await _productService.UpdateAsync(dto);

        // Invalidate caches
        await _cacheService.RemoveAsync("products:all");
        await _cacheService.RemoveAsync($"product:{id}");

        return NoContent();
    }

    [HttpDelete("{id}")]
    public async Task<ActionResult> Delete(Guid id)
    {
        await _productService.DeleteAsync(id);

        // Invalidate caches
        await _cacheService.RemoveAsync("products:all");
        await _cacheService.RemoveAsync($"product:{id}");

        return NoContent();
    }
}

✅ Key Notes

Caching scope:

GetAll → caches list of products (products:all)
GetById → caches single product (product:{id})
Invalidation logic:
When a product is created, updated, or deleted, relevant keys are removed.
Cache TTL (Time to Live):
Currently set to 60 minutes

✅ Step 8 : Final Testing

Test on GetAll

Get By Id

Next Lecture Preview
Lecture 7 : Message Queues with RabbitMQ

Implementing event-driven communication, background jobs, and asynchronous processing.

🧱 Lesson 5 - Working with PostgreSQL (Multi-Database Setup)

Farrukh Rehman — Mon, 03 Nov 2025 04:17:22 +0000

Source Code Backend : https://github.com/farrukh1212cs/ECommerce-Backend.git

Source Code Frontend : https://github.com/farrukh1212cs/ECommerce-Frontend.git

PostgreSQL is a powerful open-source database widely used in enterprise and cloud systems.
In multi-tenant or SaaS environments, it’s common to support multiple database providers (e.g., MySQL, SQL Server, PostgreSQL) based on customer or deployment needs.

Our goal today:

🐳 Pull and run PostgreSQL via Docker
⚙️ Add PostgreSQL support in EF Core
🏗️ Create PostgresDbContext and design-time factory
🧱 Run migrations and verify setup

🐳 Step 1 — Pull PostgreSQL Docker Image and Run Container

Let’s start by running PostgreSQL locally inside Docker.
docker pull postgres

Run container
docker run -d --name postgres -e POSTGRES_USER=postgres -e POSTGRES_PASSWORD=Admin123! -p 5432:5432 postgres:latest

⚙️ Step 2 — Update appsettings.json

Add a new connection string for PostgreSQL in your ECommerce.API project.
"PostgreSQL":"Host=localhost;Port=5432;Database=ECommerceDb;Username=postgres;Password=Admin123!",
Now your application can dynamically choose the provider by changing:
"DatabaseProvider": "PostgreSQL"

🧱 Step 3 — Create PostgreSQL DbContext
Path : ECommerce.Infrastructure/Data/PostgresDbContext.cs

using Microsoft.EntityFrameworkCore;

namespace ECommerce.Infrastructure.Data;

public class PostgresDbContext : AppDbContext
{
    public PostgresDbContext(DbContextOptions<PostgresDbContext> options)
  : base(options)
    {
    }
}

Install Package

dotnet add ECommerce.Infrastructure package Npgsql.EntityFrameworkCore.PostgreSQL --version 8.0.11

🧩 Step 5 — Add Design-Time Factory

EF Core CLI needs this factory for dotnet ef migrations when it can’t build the host automatically.

Create PostgresDbContextFactory
Path : ECommerce.Infrastructure/Data/PostgresDbContextFactory.cs

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Design;
using Microsoft.Extensions.Configuration;

namespace ECommerce.Infrastructure.Data;

public class PostgresDbContextFactory : IDesignTimeDbContextFactory<PostgresDbContext>
{
    public PostgresDbContext CreateDbContext(string[] args)
    {
        var basePath = Path.Combine(Directory.GetCurrentDirectory(), "../ECommerce.API");
        var configuration = new ConfigurationBuilder()
            .SetBasePath(basePath)
            .AddJsonFile("appsettings.json", optional: false)
            .AddJsonFile("appsettings.Development.json", optional: true)
            .Build();

        var connectionString = configuration.GetConnectionString("PostgreSQL");

        var optionsBuilder = new DbContextOptionsBuilder<PostgresDbContext>();
        optionsBuilder.UseNpgsql(connectionString);

        return new PostgresDbContext(optionsBuilder.Options);
    }
}

Update Dependency Injection
Path : ECommerce.Infrastructure/DependencyInjection.cs

using ECommerce.Infrastructure.Data;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;

namespace ECommerce.Infrastructure;

public static class DependencyInjection
{
    public static IServiceCollection AddInfrastructure(
        this IServiceCollection services,
        IConfiguration configuration)
    {
        var provider = configuration["DatabaseProvider"] ?? "MySQL";

        if (string.Equals(provider, "SqlServer", StringComparison.OrdinalIgnoreCase))
        {
            var conn = configuration.GetConnectionString("SqlServer");
            services.AddDbContext<AppDbContext, SqlServerDbContext>(options =>
                options.UseSqlServer(conn));
        }
        else if (string.Equals(provider, "MySQL", StringComparison.OrdinalIgnoreCase))
        {
            var conn = configuration.GetConnectionString("MySQL");
            services.AddDbContext<AppDbContext, MySqlDbContext>(options =>
                options.UseMySql(conn, ServerVersion.AutoDetect(conn)));
        }
        else if (string.Equals(provider, "PostgreSQL", StringComparison.OrdinalIgnoreCase))
        {

            var conn = configuration.GetConnectionString("PostgreSQL");
            services.AddDbContext<AppDbContext, PostgresDbContext>(options =>
                options.UseNpgsql(conn));
        }
        else
        {
            throw new InvalidOperationException($"Unsupported provider: {provider}");
        }

        return services;
    }
}

🧱 Step 6 — Create Migrations
Now you can generate a separate migration folder for PostgreSQL.

dotnet ef migrations add InitPostgres -p ECommerce.Infrastructure -s ECommerce.API --context PostgresDbContext --output-dir "Migrations/PostgreSQL"
dotnet ef database update -p ECommerce.Infrastructure -s ECommerce.API --context PostgresDbContext

Total Files Changed

Let's Connect using PGAdmin

Final Test and Verify

Next Lecture Preview
Lecture 6 : Redis Caching for Performance Optimization

Installing and configuring Redis; caching responses, queries, and improving API performance.

🧱 Lesson 4 - Adding SQL Server Support (Multi-Database Setup)

Farrukh Rehman — Tue, 28 Oct 2025 17:51:54 +0000

Source Code Backend : https://github.com/farrukh1212cs/ECommerce-Backend.git

Source Code Frontend : https://github.com/farrukh1212cs/ECommerce-Frontend.git

Introduction

In Lecture 3 we added MySQL (Docker + EF Core) and wired it into our Clean Architecture solution.

In Lecture 4 we’ll add SQL Server as a second provider and make the app switchable at runtime by configuration. You’ll learn:

how to pull and run SQL Server in Docker,
how to configure appsettings.json to hold both providers,
how to implement a single DependencyInjection extension that picks the provider at startup, and
how to run EF Core migrations for SQL Server (and switch back to MySQL later).

Pull & run SQL Server from Docker Hub
docker pull mcr.microsoft.com/mssql/server:2022-latest

Run the container (works in PowerShell / Bash)
docker run -e "ACCEPT_EULA=Y" -e "SA_PASSWORD=Admin123!" -p 1433:1433 --name ecommerce-sqlserver -d mcr.microsoft.com/mssql/server:2022-latest

Notes:

Default admin user: sa
Use a strong password (example above): Admin123!
Maps container port 1433 → host 1433

Lets Connect Server using Azure Data Studio

Add / update connection strings in appsettings.json

{
  "DatabaseProvider": "SqlServer", // "MySql" or "SqlServer"
  "ConnectionStrings": {
    "MySQL": "Server=localhost;Port=3306;Database=ECommerceDb;User=root;Password=Admin123!;",
    "SqlServer": "Server=localhost,1433;Database=ECommerceDb;User Id=sa;Password=Admin123!;TrustServerCertificate=True;"

  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}

Now Install SQL Server Package
dotnet add ECommerce.Infrastructure package Microsoft.EntityFrameworkCore.SqlServer --version 8.0.21

Create New MySqlDbContext
Path : "ECommerce.Infrastructure/Data/MySqlDbContext.cs"

using Microsoft.EntityFrameworkCore;

namespace ECommerce.Infrastructure.Data;

public class MySqlDbContext : AppDbContext
{
    public MySqlDbContext(DbContextOptions<MySqlDbContext> options)
        : base(options)
    {
    }
}

Create New DBContext for SQL Server
Path : ECommerce.Infrastructure/Data/SqlServerDbContext.cs

using Microsoft.EntityFrameworkCore;

namespace ECommerce.Infrastructure.Data;

public class SqlServerDbContext : AppDbContext
{
    public SqlServerDbContext(DbContextOptions<SqlServerDbContext> options)
        : base(options)
    {
    }
}

RENAME and UPDATE DesignTimeDbContextFactory
Path : ECommerce.Infrastructure/Data/DesignTimeDbContextFactory.cs
TO ECommerce.Infrastructure/Data/MySqlDbContextFactory.cs

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Design;
using Microsoft.Extensions.Configuration;

namespace ECommerce.Infrastructure.Data;

public class MySqlDbContextFactory : IDesignTimeDbContextFactory<MySqlDbContext>
{
    public MySqlDbContext CreateDbContext(string[] args)
    {
        // Locate the API project's appsettings.json
        var basePath = Path.Combine(Directory.GetCurrentDirectory(), "../ECommerce.API");
        var configuration = new ConfigurationBuilder()
            .SetBasePath(basePath)
            .AddJsonFile("appsettings.json", optional: false)
            .AddJsonFile("appsettings.Development.json", optional: true)
            .Build();

        var connectionString = configuration.GetConnectionString("MySQL")
            ?? throw new InvalidOperationException("MySQL connection string not found in appsettings.json");

        var optionsBuilder = new DbContextOptionsBuilder<MySqlDbContext>();
        // Use a fixed version instead of ServerVersion.AutoDetect to avoid connection attempts during design-time
        optionsBuilder.UseMySql(
            connectionString,
            new MySqlServerVersion(new Version(8, 0, 36))
        );

        return new MySqlDbContext(optionsBuilder.Options);
    }
}

Create Data Factory for SQL Server
Path : ECommerce.Infrastructure/Data/SqlServerDbContextFactory.cs

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Design;
using Microsoft.Extensions.Configuration;

namespace ECommerce.Infrastructure.Data;

public class SqlServerDbContextFactory : IDesignTimeDbContextFactory<SqlServerDbContext>
{
    public SqlServerDbContext CreateDbContext(string[] args)
    {
        var basePath = Path.Combine(Directory.GetCurrentDirectory(), "../ECommerce.API");
        var configuration = new ConfigurationBuilder()
            .SetBasePath(basePath)
            .AddJsonFile("appsettings.json", optional: false)
            .AddJsonFile("appsettings.Development.json", optional: true)
            .Build();

        var connectionString = configuration.GetConnectionString("SqlServer")
            ?? throw new InvalidOperationException("SqlServer connection string not found in appsettings.json");

        var optionsBuilder = new DbContextOptionsBuilder<SqlServerDbContext>();
        optionsBuilder.UseSqlServer(connectionString);

        return new SqlServerDbContext(optionsBuilder.Options);
    }
}

Implement multi-provider DependencyInjection (Infrastructure)
Create ECommerce.Infrastructure/DependencyInjection.cs. This extension reads DatabaseProvider and registers ApplicationDbContext (or ECommerceDbContext) with the appropriate provider.

using ECommerce.Infrastructure.Data;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;

namespace ECommerce.Infrastructure;

public static class DependencyInjection
{
    public static IServiceCollection AddInfrastructure(
        this IServiceCollection services,
        IConfiguration configuration)
    {
        var provider = configuration["DatabaseProvider"] ?? "MySQL";

        if (string.Equals(provider, "SqlServer", StringComparison.OrdinalIgnoreCase))
        {
            var conn = configuration.GetConnectionString("SqlServer");
            services.AddDbContext<AppDbContext, SqlServerDbContext>(options =>
                options.UseSqlServer(conn));
        }
        else if (string.Equals(provider, "MySQL", StringComparison.OrdinalIgnoreCase))
        {
            var conn = configuration.GetConnectionString("MySQL");
            services.AddDbContext<AppDbContext, MySqlDbContext>(options =>
                options.UseMySql(conn, ServerVersion.AutoDetect(conn)));
        }
        else
        {
            throw new InvalidOperationException($"Unsupported provider: {provider}");
        }

        return services;
    }
}

Update Program file

using ECommerce.Application.Services.Implementations;
using ECommerce.Application.Services.Interfaces;
using ECommerce.Domain.Repositories;
using ECommerce.Infrastructure.Data;
using ECommerce.Infrastructure.Repositories;
using Microsoft.EntityFrameworkCore;
using ECommerce.Infrastructure;

var builder = WebApplication.CreateBuilder(args);

// ------------------------------------------------------
// Add Controllers
// ------------------------------------------------------
builder.Services.AddControllers();

// add infrastructure (DbContext + provider selection)
builder.Services.AddInfrastructure(builder.Configuration);

// ------------------------------------------------------
//  Repository Registrations
// ------------------------------------------------------
builder.Services.AddScoped<IProductRepository, ProductRepository>();
builder.Services.AddScoped<ICustomerRepository, CustomerRepository>();
builder.Services.AddScoped<IOrderRepository, OrderRepository>();
builder.Services.AddScoped<IOrderItemRepository, OrderItemRepository>();


// ------------------------------------------------------
//  Service Registrations (Application Layer)
// ------------------------------------------------------
builder.Services.AddScoped<IProductService, ProductService>();
builder.Services.AddScoped<ICustomerService, CustomerService>();
builder.Services.AddScoped<IOrderService, OrderService>();
builder.Services.AddScoped<IOrderItemService, OrderItemService>();


// ------------------------------------------------------
//  Swagger
// ------------------------------------------------------
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();


var app = builder.Build();

// ------------------------------------------------------
// Middleware Pipeline
// ------------------------------------------------------
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

*Now Move Old (MYSQL) migrations to MySQL folder *

mkdir Migrations\MySQL
move Migrations\*.cs Migrations\MySQL\

Lets Create Migrations for SQL Server

dotnet ef migrations add InitSqlServer -p ECommerce.Infrastructure -s ECommerce.API --context SqlServerDbContext --output-dir "Migrations/SqlServer"

Lets Test with SQL Server using swagger

Next Lecture Preview
Lecture 5 : Working with PostgreSQL

Configuring Entity Framework Core for multiple providers and supporting PostgresSQL alongside MySQL and SQL Server