Forem: Mohamad Lawand

.NET 8 💥 - Intro to Kubernetes for .NET Devs

Mohamad Lawand — Tue, 18 Jun 2024 21:56:33 +0000

All .NET developers will eventually need to deploy their code, and one effective method is through Kubernetes.

In this video, I will provide a comprehensive explanation of Kubernetes tailored specifically for .NET developers. I will cover the fundamentals of Kubernetes, how it operates, and demonstrate how .NET web applications can seamlessly integrate within a Kubernetes infrastructure. This guide aims to demystify Kubernetes and empower .NET developers with the knowledge to effectively leverage this powerful deployment tool.

You can follow me

📹 Youtube - http://youtube.com/@mohamadlawand
♯ Github - https://github.com/mohamadlawand087
🎫 LinkedIn - https://www.linkedin.com/in/mlawand
💥 LinkTree - https://linktr.ee/mohamadlawand

.NET 6 - Background Jobs with Hangfire 🔥🔥🔥

Mohamad Lawand — Thu, 03 Nov 2022 05:38:33 +0000

In This article we will be discussing how we can implement background jobs in .Net with Hangfire library

You can watch the full video on youtube:

If you would like to have full access to the source code please consider supporting me on Patreon
https://www.patreon.com/mohamadlawand

Will start by doing an over view of what are background jobs

Background Jobs

They are tasks that runs in the background without any user interventions which help the application to run smoothly.

Some of the examples of the background

for long and lengthy operations like data processing .
Batch import from APIs, files …
Synchronisation functionalities
Reporting functionalities.
Notification services.

Hangfire Overview

Hangfire is open-source and used to schedule background jobs at a particular event and time.
Hangfire will do background processing without user intervention.
Hangfire provides a dashboard which helps manage everything

Hangfire job types

Hangfire support different job types which are listed below

Fire-and-Forget Job: are executed only one time after certain conditions, we don’t care about the outcome of the job.

Delayed Job: are executed only once but after a specific interval of time.

Recurring Job: are ****executed many times after specified condition and time interval

Continuations Job: are ****executed when its parent job is executed and finished.

Coding

Now lets create the app

dotnet new webapi -n "FireAPI"

Next we need to install the packages

dotnet add package Hangfire 
dotnet add package Hangfire.Core 
dotnet add package Hangfire.Storage.SQLite 
dotnet add package Hangfire.Dashboard.Basic.Authentication

We need to add the connection string to our Sqlite inside the appsettings.json

"ConnectionStrings": {
    "DefaultConnection": "app.db"
  }

Now we need to configure our Hangfire configuration inside our Program.cs

builder.Services.AddHangfire(configuration => configuration
            .UseSimpleAssemblyNameTypeSerializer()
            .UseRecommendedSerializerSettings()
            .UseSQLiteStorage(builder.Configuration.GetConnectionString("DefautConnection")));

// Add the processing server as IHostedService
builder.Services.AddHangfireServer();

app.UseHangfireDashboard();
app.MapHangfireDashboard();

Now let us add a Models folder and add our first Model Driver.cs

public class Driver
{
    public Guid Id { get; set; }
    public string Name { get; set; } = "";
    public int DriverNumber { get; set; }
    public int Status {get;set;}
}

Next we need to add a controller which will allow us to manage drivers, we will be utilising an in-memory database.

using FireApp.Models;
using Microsoft.AspNetCore.Mvc;

namespace FireApp.Controllers;

[ApiController]
[Route("[controller]")]
public class DriversController : ControllerBase
{
    private static List<Driver> drivers = new List<Driver>();

    private readonly ILogger<DriversController> _logger;

    public DriversController(ILogger<DriversController> logger)
    {
        _logger = logger;
    }

    [HttpGet]
    public IActionResult GetDrivers()
    {
        var items = drivers.Where(x => x.Status == 1).ToList();
        return Ok(items);
    }

    [HttpPost]
    public IActionResult CreateDriver(Driver data)
    {
        if(ModelState.IsValid)
        {
            drivers.Add(data);

            return CreatedAtAction("GetDriver", new {data.Id}, data);
        }

        return new JsonResult("Something went wrong") {StatusCode = 500};
    }

    [HttpGet("{id}")]
    public IActionResult GetDriver(Guid id)
    {
        var item = drivers.FirstOrDefault(x => x.Id == id);

        if(item == null)
            return NotFound();

        return Ok(item);
    }

    [HttpPut("{id}")]
    public IActionResult UpdateDriver(Guid id, Driver item)
    {
        if(id != item.Id)
            return BadRequest();

        var existItem = drivers.FirstOrDefault(x => x.Id == id);

        if(existItem == null)
            return NotFound();

        existItem.Name = item.Name;
        existItem.DriverNumber = item.DriverNumber;

        return NoContent();
    }

    [HttpDelete("{id}")]
    public IActionResult DeleteDriver(Guid id)
    {
        var existItem = drivers.FirstOrDefault(x => x.Id == id);

        if(existItem == null)
            return NotFound();

        existItem.Status = 0;

        return Ok(existItem);
    }
}

Now let us create a service which will be responsible to sending emails, updating database …

In the root directory of the app we need to create a new folder called Services and add the following interface IServiceManagement

namespace FireApp.Services;

public interface IServiceManagement
{
    void SendEmail();
    void UpdateDatabase();
    void GenerateMerchandise();
    void SyncRecords();
}

Now let us build an implementation of this interface

namespace FireApp.Services;

public class ServiceManagement : IServiceManagement
{
    public void GenerateMerchandise()
    {
       Console.WriteLine($"Generate Merchandise: long running service at {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}");
    }

    public void SendEmail()
    {
        Console.WriteLine($"Send Email: delayed execution service at {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}");
    }

    public void SyncRecords()
    {
        Console.WriteLine($"Sync Records: at {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}");
    }

    public void UpdateDatabase()
    {
        Console.WriteLine($"Update Database: at {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}");
    }
}

We need to add the service implementation into the FireApp

builder.Services.AddScoped<IServiceManagement, ServiceManagement>();

Now let us add a long running service which we want to execute every 4h

RecurringJob.AddOrUpdate<IServiceManagement>(x => x.SyncRecords(), "0 * * ? * *");

For help with cron expression, check the following website: https://www.freeformatter.com/cron-expression-generator-quartz.html

Now let us update the controller to add the services

using FireApp.Models;
using FireApp.Services;
using Hangfire;
using Microsoft.AspNetCore.Mvc;

namespace FireApp.Controllers;

[ApiController]
[Route("[controller]")]
public class DriversController : ControllerBase
{
    private static List<Driver> drivers = new List<Driver>();

    private readonly ILogger<DriversController> _logger;

    public DriversController(
        ILogger<DriversController> logger)
    {
        _logger = logger;
    }

    [HttpGet]
    public IActionResult GetDrivers()
    {
        var items = drivers.Where(x => x.Status == 1).ToList();
        return Ok(items);
    }

    [HttpPost]
    public IActionResult CreateDriver(Driver data)
    {
        if(ModelState.IsValid)
        {
            drivers.Add(data);

            // Fire and Forget Job
            var jobId = BackgroundJob.Enqueue<IServiceManagement>(x => x.SendEmail());
            Console.WriteLine($"Job id: {jobId}");

            return CreatedAtAction("GetDriver", new {data.Id}, data);
        }

        return new JsonResult("Something went wrong") {StatusCode = 500};
    }

    [HttpGet("{id}")]
    public IActionResult GetDriver(Guid id)
    {
        var item = drivers.FirstOrDefault(x => x.Id == id);

        if(item == null)
            return NotFound();

        return Ok(item);
    }

    [HttpPut("{id}")]
    public IActionResult UpdateDriver(Guid id, Driver item)
    {
        if(id != item.Id)
            return BadRequest();

        var existItem = drivers.FirstOrDefault(x => x.Id == id);

        if(existItem == null)
            return NotFound();

        existItem.Name = item.Name;
        existItem.DriverNumber = item.DriverNumber;

        var jobId = BackgroundJob.Schedule<IServiceManagement>(x => x.UpdateDatabase(), TimeSpan.FromSeconds(20));
        Console.WriteLine($"Job id: {jobId}");

        return NoContent();
    }

    [HttpDelete("{id}")]
    public IActionResult DeleteDriver(Guid id)
    {
        var existItem = drivers.FirstOrDefault(x => x.Id == id);

        if(existItem == null)
            return NotFound();

        existItem.Status = 0;

        RecurringJob.AddOrUpdate<IServiceManagement>(x => x.SyncRecords(), Cron.Hourly);

        return Ok(existItem);
    }
}

Securing Hangfire

AppSetting.json we need to update it to the following

"HangfireCredentials": {  
    "UserName": "mohamad",  
    "Password": "Passw0rd"  
  }

And we need to update the program.cs to the following

app.UseHangfireDashboard("/hangfire", new DashboardOptions()
{
        DashboardTitle = "Hangfire Dashboard",  
    Authorization = new[]{  
    new HangfireCustomBasicAuthenticationFilter{  
        User = Configuration.GetSection("HangfireCredentials:UserName").Value,  
        Pass = Configuration.GetSection("HangfireCredentials:Password").Value  
    }
});

Please ask any questions in the comments down below.

.NET 6 - AutoMapper & Data Transfer Objects (DTOs) 🗺

Mohamad Lawand — Tue, 18 Oct 2022 10:33:26 +0000

Intro

In this article we will be exploring AutoMapper and Data Transfer Objects (DTOs) in .Net 6 Web Api. You can watch the full video on YouTube

We can start today by explaining what is AutoMapper and why do we need it

AutoMapper is a library that helps us to transform one object type to another in a very easy accurate way.

We start by creating our web API

dotnet new webapi -n SampleMapper

Once we create our application we need to install the AutoMapper nuget package into our application

dotnet add package AutoMapper --version 12.0.0
dotnet add package AutoMapper.Extensions.Microsoft.DependencyInjection --version 12.0.0

Now that our nuget packages are installed we can start implementing and utilising automapper.

In this example we will be building a simple api which will take DTOs which the client sends and we will be utilising automapper to transform the objs into database obj and vise versa when we get any obj from the data we will do some data transformation to the client so we are not returning the full object

The first thing we need to do is to create a new folder called models which will represent our database tables. Inside the root app directory we add this folder and inside the Models folder we create a new class called Driver and we add the following to it

namespace SampleMapper.Models;

public class Driver
{
    public Guid Id { get; set; }
    public string FirstName { get; set; } = "";
    public string LastName { get; set; } = "";
    public int DriverNumber { get; set; }
    public DateTime DateAdded { get; set; }
    public DateTime DateUpdated { get; set; }
    public int Status { get; set; }
    public int WorldChampionships { get; set; }
}

Next we need to create a controller which will responsible for handling all of the Driver requests. In order to make this example as simple as possible we will be using an in-memory database instead of a full database.

using Microsoft.AspNetCore.Mvc;
using SampleMapper.Models;

namespace SampleMapper.Controllers;

[ApiController]
[Route("[controller]")]
public class DriversController : ControllerBase
{
    private static List<Driver> drivers = new List<Driver>();

    private readonly ILogger<DriversController> _logger;

    public DriversController(ILogger<DriversController> logger)
    {
        _logger = logger;
    }

    [HttpGet]
    public IActionResult GetDrivers()
    {
        var items = drivers.Where(x => x.Status == 1).ToList();
        return Ok(items);
    }

    [HttpPost]
    public IActionResult CreateDriver(Driver data)
    {
        if(ModelState.IsValid)
        {
            drivers.Add(data);

            return CreatedAtAction("GetDriver", new {data.Id}, data);
        }

        return new JsonResult("Something went wrong") {StatusCode = 500};
    }

    [HttpGet("{id}")]
    public IActionResult GetDriver(Guid id)
    {
        var item = drivers.FirstOrDefault(x => x.Id == id);

        if(item == null)
            return NotFound();

        return Ok(item);
    }

    [HttpPut("{id}")]
    public IActionResult UpdateDriver(Guid id, Driver item)
    {
        if(id != item.Id)
            return BadRequest();

        var existItem = drivers.FirstOrDefault(x => x.Id == id);

        if(existItem == null)
            return NotFound();

        existItem.FirstName = item.FirstName;
        existItem.LastName = item.LastName;
        existItem.DriverNumber = item.DriverNumber;
        existItem.WorldChampionships = item.WorldChampionships;


        return NoContent();
    }

    [HttpDelete("{id}")]
    public IActionResult DeleteDriver(Guid id)
    {
        var existItem = drivers.FirstOrDefault(x => x.Id == id);

        if(existItem == null)
            return NotFound();

        existItem.Status = 0;

        return Ok(existItem);
    }
}

Now let us see how we can transform this into a more optimised API and more user friendly.

Inside the Models folder we create a new folder called DTOs, inside the DTOs folder we create 2 new folders called

incoming: responsible for all incoming requests to our API
outgoing: responsible for all outgoing requests from our API

Will start by the incoming request. Inside the incoming folder we add the following class

namespace SampleMapper.Models.DTOs.Incoming;

public class DriverCreationDto
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int DriverNumber { get; set; }
    public int WorldChampionships { get; set; }
}

Now let us update the controller to take advantage of this DTO

[HttpPost]
public IActionResult CreateDriver(DriverCreationDto data)
{
    var _driver = new Driver()
    {
        Id = Guid.NewGuid(),
        Status = 1,
        DateAdded = DateTime.Now,
        DateUpdated = DateTime.Now,
        DriverNumber = data.DriverNumber,
        FirstName = data.FirstName,
        LastName = data.LastName,
        WorldChampionships = data.WorldChampionships
    };
    if(ModelState.IsValid)
    {
        drivers.Add(_driver);

        return CreatedAtAction("GetDriver", new {_driver.Id}, data);
    }

    return new JsonResult("Something went wrong") {StatusCode = 500};
}

We can see that there is an advantage by using the Dto but it still not what we need, we are still doing manual mapping between 2 objs.

Here we can see how AutoMapper will be able to help us

Inside the rood directory of the application we are going to create a new folder called Profiles, inside the folder we need to create a new class called DriverProfile and update it to the following

using AutoMapper;
using SampleMapper.Models;
using SampleMapper.Models.DTOs.Incoming;

namespace SampleMapper.Profiles;

public class DriverProfile : Profile
{
    public DriverProfile()
    {
        CreateMap<DriverCreationDto, Driver>()
            .ForMember(
                dest => dest.Id,
                opt => opt.MapFrom(src => Guid.NewGuid())
            )
            .ForMember(
                dest => dest.FirstName,
                opt => opt.MapFrom(src => $"{src.FirstName} ")
            )
            .ForMember(
                dest => dest.LastName,
                opt => opt.MapFrom(src => $"{src.LastName}")
            )
            .ForMember(
                dest => dest.WorldChampionships,
                opt => opt.MapFrom(src => src.WorldChampionships)
            )
            .ForMember(
                dest => dest.Status,
                opt => opt.MapFrom(src => 1)
            )
            .ForMember(
                dest => dest.DriverNumber,
                opt => opt.MapFrom(src => src.DriverNumber)
            );
    }
}

Now let us update controller to utilise the automapper functionalities

private readonly IMapper _mapper;

    public DriversController(
        ILogger<DriversController> logger,
        IMapper mapper)
    {
        _logger = logger;
        _mapper = mapper;
    }

[HttpPost]
    public IActionResult CreateDriver(DriverCreationDto data)
    {
        var _driver = _mapper.Map<Driver>(data);

        if(ModelState.IsValid)
        {
            drivers.Add(_driver);

            return CreatedAtAction("GetDriver", new {_driver.Id}, data);
        }

        return new JsonResult("Something went wrong") {StatusCode = 500};
    }

We also need to update our program.cs to inject AutoMapper into our DI container

builder.Services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies());

Inside Outgoing folder we need add a new class called DriverDto and add the following

public class DriverDto
{
    public Guid Id { get; set; }
    public string FullName { get; set; }
    public int DriverNumber { get; set; }
    public int WorldChampionships { get; set; }
}

Now let us utilise this DTO by updating our profile class to the following

CreateMap<Driver, DriverDto>()
            .ForMember(
                dest => dest.Id,
                opt => opt.MapFrom(src => Guid.NewGuid())
            )
            .ForMember(
                dest => dest.FullName,
                opt => opt.MapFrom(src => $"{src.FirstName} {src.LastName}")
            )
            .ForMember(
                dest => dest.DriverNumber,
                opt => opt.MapFrom(src => $"{src.DriverNumber}")
            )
            .ForMember(
                dest => dest.WorldChampionships,
                opt => opt.MapFrom(src => src.WorldChampionships)
            );

And now let us update our controller to take advantage to the following

[HttpGet]
    public IActionResult GetDrivers()
    {
        var items = drivers.Where(x => x.Status == 1).ToList();

        var driverList = _mapper.Map<IEnumerable<DriverDto>>(items);
        return Ok(driverList);
    }

Thank you for reading.

.NET 6 - Web API Global Exceptions Handling 🌐

Mohamad Lawand — Wed, 21 Sep 2022 05:57:27 +0000

Intro

In this article we will be exploring Global Error Handling in .Net 6 Web Api. You can watch the full video on youtube

You can find the full source code on github

mohamadlawand087 / net-globalexcpetions

Agenda

Introduction
Implementation of Global Exception Handling

Prerequisites

Visual Studio Code / Visual Studio / Rider
.NET Core 6 SDK
Understanding of C# Programming
Understanding of .NET Core APIs

Introduction

When we are building our application, although we hope that our application will run without any errors until the end of time. This is not really the case exceptions happens in applications and we need to handle them.

Exception Handling is a foundation that we need to consider while we are designing and building our application to have a stable application and avoid application crashes.

There are many ways to implement exception handling while building our applications from a very granular approach to a more generic way.

In this article we will be exploring global exception handling through middleware to catch runtime errors efficiently as per our requirement

Code

The first thing we need to do is to create a new WebApi application

dotnet new webapi -n ErrorManagement

Now that our application has been created we need to install some packages

dotnet add package Microsoft.EntityFrameworkCore 
dotnet add package Microsoft.EntityFrameworkCore.Design 
dotnet add package Npgsql.EntityFrameworkCore.PostgreSQL
dotnet add package Microsoft.EntityFrameworkCore.Tools

To make sure everything is running as it should we need to build our application

dotnet build

Now it’s time to add the models, for this sample application we will be creating an app to list all F1 drivers. For this we will create a Models folder in the root directory of our application which will contain our models

Inside the Models folder we will create a new class called Driver

namespace ErrorManagement.Models;
public class Driver
{
    public int Id { get; set; }
    public string Name { get; set; } = "";
    public int DriverNumber { get; set; }
    public string Team { get; set; } = "";
}

After the model has been created the next step is to create our database db context in the root directory of our application we will create a new folder called Data and inside the Data folder will add the AppDbContext class

using ErrorManagement.Models;
using Microsoft.EntityFrameworkCore;

namespace ErrorManagement.Data;

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

    public DbSet<Driver> Drivers { get; set; }
}

Now we need to add the connection string in the appsettings.json

"ConnectionStrings": {
    "SampleDbConnection": "User ID =mohamad;Password=12345678;Server=localhost;Port=5432;Database=sampledb; Integrated Security=true;Pooling=true;"
  }

Next we need to update our program.cs

builder.Services.AddEntityFrameworkNpgsql().AddDbContext<ApiDbContext>(opt =>
        opt.UseNpgsql(builder.Configuration.GetConnectionString("SampleDbConnection")));

Once we add these we can do our migration

dotnet ef migrations add "initial_migration"
dotnet ef database update

Now lets create the DriverServices in the root directory of our application let us create a new folder called Services and inside that folder we will create a new interface called IDriverService

using ErrorManagement.Models;

namespace ErrorManagement.Services;

public interface IDriverService
{
    public Task<IEnumerable<Driver>> GetDrivers();
    public Task<Driver?> GetDriverById(int id);
    public Task<Driver> AddDriver(Driver Driver);
    public Task<Driver> UpdateDriver(Driver Driver);
    public Task<bool> DeleteDriver(int Id);
}

Now inside the same folder we will create a new class called DriverService

using ErrorManagement.Data;
using ErrorManagement.Models;
using Microsoft.EntityFrameworkCore;

namespace ErrorManagement.Services;

public class DriverService : IDriverService
{
    private readonly AppDbContext _dbContext;

    public DriverService(AppDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public async Task<IEnumerable<Driver>> GetDrivers()
    {
        return  await _dbContext.Drivers.ToListAsync();
    }

    public async Task<Driver?> GetDriverById(int id)
    {
        return await _dbContext.Drivers.FirstOrDefaultAsync(x => x.Id == id);
    }

    public async Task<Driver> AddDriver(Driver Driver)
    {
        var result = _dbContext.Drivers.Add(Driver);
        await _dbContext.SaveChangesAsync();
        return result.Entity;
    }

    public async Task<Driver> UpdateDriver(Driver Driver)
    {
        var result = _dbContext.Drivers.Update(Driver);
        await _dbContext.SaveChangesAsync();
        return result.Entity;
    }

    public async Task<bool> DeleteDriver(int Id)
    {
        var filteredData = _dbContext.Drivers.FirstOrDefault(x => x.Id == Id);
        var result = _dbContext.Remove(filteredData);
        await _dbContext.SaveChangesAsync();
        return result != null ? true : false;
    }
}

Let us now update our Program.cs so our DriverServices would be injected in our Dependency Inject container

builder.Services.AddScoped<IDriverService, DriverService>();

Now lets create our DriverController, insider the controller folder we will create a new class called DriversController and will add the following

using ErrorManagement.Models;
using ErrorManagement.Services;
using Microsoft.AspNetCore.Mvc;

namespace ErrorManagement.Controllers;

[ApiController]
[Route("[controller]")]
public class DriversController : ControllerBase
{
    private readonly ILogger<WeatherForecastController> _logger;
    private readonly IDriverService _driverServices;

    public DriversController(
        ILogger<WeatherForecastController> logger,
        IDriverService driverServices)
    {
        _logger = logger;
        _driverServices = driverServices;
    }

    [HttpGet("driverlist")]
    public async Task<IEnumerable<Driver>> DriverList()
    {
        var driverList = await _driverServices.GetDrivers();
        return driverList;
    }

    [HttpGet("getdriverbyid")]
    public async Task<IActionResult> GetDriverById(int Id)
    {
        _logger.LogInformation($"Fetch Driver with ID: {Id} from the database");
        var driver = await _driverServices.GetDriverById(Id);
        if (driver == null)
        {
            //throw new Notfound($"Driver ID {Id} not found.");
            return NotFound();
        }
        _logger.LogInformation($"Returning driver with ID: {driver.Id}.");
        return Ok(driver) ;
    }

    [HttpPost("adddriver")]
    public async Task<IActionResult> AddDriver(Driver driver)
    {
        var result = await _driverServices.AddDriver(driver);
        return Ok(result);
    }

    [HttpPut("updatedriver")]
    public async Task<IActionResult> UpdateDriver(Driver driver)
    {
        var result = await _driverServices.UpdateDriver(driver);
        return Ok(result);
    }

    [HttpDelete("deletedriver")]
    public async Task<bool> DeleteDriver(int Id)
    {
        return await _driverServices.DeleteDriver(Id);
    }
}

Now let us add a new folder called Exceptions which will be utilised to manage all of our exceptions

We will be adding the following exceptions

namespace ErrorManagement.Exceptions;

public class BadRequestException : Exception
{
    public BadRequestException(string message) : base(message)
    { }
}

namespace ErrorManagement.Exceptions;

public class KeyNotFoundException : Exception
{
    public KeyNotFoundException(string message) : base(message)
    { }
}

namespace ErrorManagement.Exceptions;

public class NotFoundException : Exception
{
    public NotFoundException(string message) : base(message)
    { }
}

namespace ErrorManagement.Exceptions;

public class NotImplementedException : Exception
{
    public NotImplementedException(string message) : base(message)
    { }
}

namespace ErrorManagement.Exceptions;

public class UnauthorizedAccessException : Exception
{
    public UnauthorizedAccessException(string message) : base(message)
    { }
}

Now that our exceptions has been added, we need to add a folder to the root directory of our application called configurations where we can build our GlobalErrorHandlingMiddleware

using System.Net;
using System.Text.Json;
using ErrorManagement.Exceptions;

using KeyNotFoundException = ErrorManagement.Exceptions.KeyNotFoundException;
using NotImplementedException = ErrorManagement.Exceptions.NotImplementedException;
using UnauthorizedAccessException = ErrorManagement.Exceptions.UnauthorizedAccessException;

namespace ErrorManagement.Configurations;

public class GlobalErrorHandlingMiddleware
{
    private readonly RequestDelegate _next;

    public GlobalErrorHandlingMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task Invoke(HttpContext context)
    {
        try
        {
            await _next(context);
        }
        catch (Exception ex)
        {
            await HandleExceptionAsync(context, ex);
        }
    }

    private static Task HandleExceptionAsync(HttpContext context, Exception exception)
    {
        HttpStatusCode status;
        var stackTrace = string.Empty;
        string message;

        var exceptionType = exception.GetType();

        if (exceptionType == typeof(BadRequestException))
        {
            message = exception.Message;
            status = HttpStatusCode.BadRequest;
            stackTrace = exception.StackTrace;
        }
        else if (exceptionType == typeof(NotFoundException))
        {
            message = exception.Message;
            status = HttpStatusCode.NotFound;
            stackTrace = exception.StackTrace;
        }
        else if (exceptionType == typeof(NotImplementedException))
        {
            status = HttpStatusCode.NotImplemented;
            message = exception.Message;
            stackTrace = exception.StackTrace;
        }
        else if (exceptionType == typeof(UnauthorizedAccessException))
        {
            status = HttpStatusCode.Unauthorized;
            message = exception.Message;
            stackTrace = exception.StackTrace;
        }
        else if (exceptionType == typeof(KeyNotFoundException))
        {
            status = HttpStatusCode.Unauthorized;
            message = exception.Message;
            stackTrace = exception.StackTrace;
        }
        else
        {
            status = HttpStatusCode.InternalServerError;
            message = exception.Message;
            stackTrace = exception.StackTrace;
        }

        var exceptionResult = JsonSerializer.Serialize(new { error = message, stackTrace });
        context.Response.ContentType = "application/json";
        context.Response.StatusCode = (int)status;

        return context.Response.WriteAsync(exceptionResult);
    }
}

The GlobalErrorHandlingMiddleware is used to provide more control over exceptions which the application will generate

If there is any errors within an incoming request the GlobalErrorHandlingMiddleware will handle the error

Now lets create ApplicationBuilderExtension so we can inject our middleware inside the Services folder

namespace ErrorManagement.Configurations;

public static class ApplicationBuilderExtensions
{
    public static IApplicationBuilder AddGlobalErrorHandler(this IApplicationBuilder applicationBuilder)
        => applicationBuilder.UseMiddleware<GlobalErrorHandlingMiddleware>();
}

Now let us inject this in the Program.cs

app.AddGlobalErrorHandler();

Please provide your feedback and ask any question.

.NET 6 - Web API Logging 📝

Mohamad Lawand — Sat, 10 Sep 2022 12:25:29 +0000

In this article we will be discussing logs in .NET 6 WebAPI and how we can utilise the WatchDog package to integrate it within our application.

You can watch the full video on youtube

And you can find the full source code on Github
https://github.com/mohamadlawand087/webapi-log

Why use WatchDog:

RealTime HTTP Request and Response Logger
RealTime Exception Logger
In-code message and event logging
User Friendly Logger Views
Search Option for HTTP and Exception Logs
Filtering Option for HTTP Logs using HTTP Methods and StatusCode
Logger View Authentication
Auto Clear Logs Option

Code

Create a new WebApi application

dotnet new webpi -n DataLog

Install the nuget package

dotnet add package WatchDog.NET

Now we need to configure our application to work with the DogWatch library inside the program.cs we need to add the following

builder.Services.AddWatchDogServices();

We can take the WatchDog service configuration to the next step by updating the following

builder.Services.AddWatchDogServices(opt =>
{
    opt.IsAutoClear = true; // clears the logs after a specific duration
    opt.ClearTimeSchedule = WatchDog.src.Enums.WatchDogAutoClearScheduleEnum.Monthly; // specify when it will automatically clear the logs
});

We want to be able to store the logs in a database so we can refer back to them, for that we will be utilising PostgreSQL

First we need to make sure that PostgreSQL is installed on our machine

brew install postgresql

Starting and Stoping Postgres is running

brew services start postgresql
brew services stop postgresql

Connect with Postgres

psql postgres

Create User and Pass so we can utilise them in our .NET app

CREATE ROLE devuser WITH LOGIN PASSWORD '12345678';
ALTER ROLE devuser CREATEDB;
ALTER ROLE devuser WITH Superuser;

Create a Database

create database sampledblogs;

Grand permission to the db

GRANT CONNECT ON DATABASE sampledb TO mohamad;

Update AppSettings with connection string

"ConnectionStrings": {
    "SampleDbConnection": "User ID =devuser;Password=12345678;Server=localhost;Port=5432;Database=samplelogs; Integrated Security=true;Pooling=true;"
  }

Now we need to enable the db connection to watch dog

builder.Services.AddWatchDogServices(opt => 
{
    opt.IsAutoClear = false;
    opt.SetExternalDbConnString = builder.Configuration.GetConnectionString("SampleDbConnection");
    opt.SqlDriverOption = WatchDog.src.Enums.WatchDogSqlDriverEnum.PostgreSql;
});

Now we need to enable exception logs

app.UseWatchDogExceptionLogger();

Next we need to enable admin portal

app.UseWatchDog(opt => 
{ 
   opt.WatchPageUsername = "admin"; 
   opt.WatchPagePassword = "Mohamad123!"; 
 });

.NET 6 - Web API Correlation Id 🔗

Mohamad Lawand — Sat, 03 Sep 2022 07:55:33 +0000

In this article we will be cover Correlation Id in APIs and howe can add them to our .NET Web API and utilise them.

You can watch the full video on youtube:

And find the full source code on github:
https://github.com/mohamadlawand087/Api-Correlation

A Correlation ID is a unique identifier value that is attached to requests and messages that allow reference to a particular transaction or event chain. Attaching a Correlation ID to a request is arbitrary.

Create a new project

dotnet new webapi -n CorrerlationApi

Once we open it in VS Code, we need to add a new folder in the root directory called Configurations

Inside the Configurations folder we need to create a new folder called interfaces and inside the interface we need to create an interface called ICorrelationIdGenerator

namespace CorrerlationApi.Configurations.Interfaces;

public interface ICorrelationIdGenerator
{
    string Get();
    void Set(string correlationId);
}

Now inside the Configuration folder we need to create the CorrelationIdGenerator class

using ApiCorrolation.Configurations.Interfaces;

namespace CorrerlationApi.Configurations;

public class CorrelationIdGenerator : ICorrelationIdGenerator
{
    private string _correlationId = Guid.NewGuid().ToString();

    public string Get() => _correlationId;

    public void Set(string correlationId) { 
            _correlationId = correlationId;
        }
}

Since the CorrolationId would be generated per request, not across the lifetime of the application we need to inject the CorrelationIdGenerator as a Scoped service rather then a singleton one

To register the Correlation Id we can utilise an extension method so inside the Configuration folder we will create a new folder called Services

Inside the Services folder we create a new class called ServiceCollectionExtensions and we add the following

using CorrerlationApi.Configurations.Interfaces;
using CorrerlationApi.Configurations;

namespace CorrerlationApi.Services;

public static class ServiceCollectionExtensions
{
    public static IServiceCollection AddCorrelationIdGeneratorService(this IServiceCollection services)
    {
        services.AddScoped<ICorrelationIdGenerator, CorrelationIdGenerator>();

        return services;
    }
}

The next step is attach the services to the application startup in the program.cs

builder.Services.AddCorrelationIdGeneratorService();

Now that our CorrelationId services are able to be injected scoped, we need to create the middleware which is responsible for catching the incoming request, analysing it for correlation-id in the header

inside the root directory we create a new folder called Helpers and inside the Helpers folder we create a new class called CorrelationIdMiddleare.cs and we add the following

using CorrerlationApi.Configurations.Interfaces;
using Microsoft.Extensions.Primitives;

namespace CorrerlationApi.Helpers;

public class CorrelationIdMiddleware
{
    private readonly RequestDelegate _next;
    private const string _correlationIdHeader = "X-Correlation-Id";

    public CorrelationIdMiddleware(RequestDelegate next) { 
            _next = next; 
        }

    public async Task Invoke(HttpContext context, ICorrelationIdGenerator correlationIdGenerator)
    {
        var correlationId = GetCorrelationId(context, correlationIdGenerator);
        AddCorrelationIdHeaderToResponse(context, correlationId);

        await _next(context);
    }

    private static StringValues GetCorrelationId(HttpContext context, ICorrelationIdGenerator correlationIdGenerator)
    {
        if(context.Request.Headers.TryGetValue(_correlationIdHeader, out var correlationId))
        {
            correlationIdGenerator.Set(correlationId);
            return correlationId;
        }
        else
        {
            return correlationIdGenerator.Get();
        }
    }

    private static void AddCorrelationIdHeaderToResponse(HttpContext context, StringValues correlationId)
    { 
                context.Response.OnStarting(() =>
        {
            context.Response.Headers.Add(_correlationIdHeader, new[] {correlationId.ToString()});
            return Task.CompletedTask;
        });
        }
}

The next step is injecting the middleware in the application startup inside the Services folder we create a new class called ApplicationBuilderExtensions

using CorrerlationApi.Helpers;

namespace CorrerlationApi.Services;

public static class ApplicationBuilderExtensions
{
    public static IApplicationBuilder AddCorrelationIdMiddleware(this IApplicationBuilder applicationBuilder)
        => applicationBuilder.UseMiddleware<CorrelationIdMiddleware>();
}

And we need to update the program.cs with the following

app.AddCorrelationIdMiddleware();

Lastly let us test the functionality in our controller, by updating the WeatherForcastController with the following

using CorrerlationApi.Configurations.Interfaces;
using CorrerlationApi.Services;
using Microsoft.AspNetCore.Mvc;

namespace CorrerlationApi.Controllers;

[ApiController]
[Route("[controller]")]
public class WeatherForecastController : ControllerBase
{
    private static readonly string[] Summaries = new[]
    {
        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
    };

    private readonly ICorrelationIdGenerator _correlationIdGenerator;

    private readonly ILogger<WeatherForecastController> _logger;

    public WeatherForecastController(
        ILogger<WeatherForecastController> logger,
        ICorrelationIdGenerator correlationIdGenerator)
    {
        _logger = logger;
         _correlationIdGenerator = correlationIdGenerator;
    }

    [HttpGet(Name = "GetWeatherForecast")]
    public IEnumerable<WeatherForecast> Get()
    {
        _logger.LogInformation("CorrelationId {correlationId}: Processing weather forecast request",
            _correlationIdGenerator.Get());

        return Enumerable.Range(1, 5).Select(index => new WeatherForecast
        {
            Date = DateTime.Now.AddDays(index),
            TemperatureC = Random.Shared.Next(-20, 55),
            Summary = Summaries[Random.Shared.Next(Summaries.Length)]
        })
        .ToArray();
    }
}

Please comment any of your questions and thank you for reading.

Setup your M1 MacBook Pro for .NET and iOS development

Mohamad Lawand — Fri, 26 Aug 2022 13:28:03 +0000

In this article we will look on how we can step up an M1 MacBook Pro for development.

You can watch the full video on YouTube

To get started after the initial setup of the laptop the main items that I change from the configuration are the following

Finder ⇒ Show Status Bar
Finder ⇒ Show Path Bar
Customise Toolbar ⇒ add the New folder
Dock & Menu Bar customisation ⇒
- make it smaller
- show hide
- remove spotlight from menu bar

Once that is done, the next step is installing the IDEs that I would be using on daily basis.

Rider (https://www.jetbrains.com/rider/)
Xcode (https://developer.apple.com/xcode/)
VSCode (https://code.visualstudio.com)

Next we need to install the Dev Tools

Docker (https://docs.docker.com/get-docker/)
Homebrew (https://brew.sh)

Now that we have installed homebrew we can utilise it to install the rest of the packages/apps that we need

iTerm (https://formulae.brew.sh/cask/iterm2)
- oh-my-zsh (https://ohmyz.sh)
- Powerlevel10k (https://github.com/romkatv/powerlevel10k#oh-my-zsh)
rectangle (https://formulae.brew.sh/cask/rectangle)
git (https://formulae.brew.sh/formula/git#default)

Now its time for some cloud CLIs

azure-cli (https://formulae.brew.sh/formula/azure-cli#default)
awscli (https://formulae.brew.sh/formula/awscli#default)

Next step if you are a web developer you will need to have all major browsers installed to test your code

Microsoft Edge (https://formulae.brew.sh/cask/microsoft-edge#default)
Firefox (https://formulae.brew.sh/cask/firefox#default)
Google Chrome (https://formulae.brew.sh/formula/chroma#default)

Being .NET dev we need to have the .NET sdk installed and since .NET 6 support ARM architecture natively, this is what we will be using.

.Net SDK https://formulae.brew.sh/cask/dotnet-sdk#default

If you build API's or deal with API's you will need a tool which will allow you to test, group and utilise all endpoints any of the below should be fine

Insomnia (https://formulae.brew.sh/cask/insomnia#default)
Postman (https://formulae.brew.sh/cask/postman#default)

If you have any suggestion or other applications that you use please mention it in the comments down below.

Advance Ef Core and PostgreSQL in .Net 6

Mohamad Lawand — Thu, 18 Aug 2022 10:01:08 +0000

In this article, we will be exploring advance Ef Core an PostgreSQL with .NET 6. The steps we need need to take to setup, configure and utilise PostgreSQL with .NET 6 WebAPI.

You can watch the full video on YouTube

You can also find the source code on Github

https://github.com/mohamadlawand087/Net6-EfCore-Postgres-V2

Changing Table Name in the database

modelBuilder.Entity<Driver>(entity =>
{
    entity.HasOne(d => d.Team)
        .WithMany(p => p.Drivers)
        .HasForeignKey(d => d.TeamId)
        .OnDelete(DeleteBehavior.Restrict)
        .HasConstraintName("FK_Driver_Team");

    entity.ToTable("F1Drivers");
});

modelBuilder.Entity<Team>().ToTable("F1Teams");

Table Comments

modelBuilder.Entity<Team>()
        .ToTable("F1Teams")
        .HasComment("This table is used to store F1 teams information");

Column Comments

modelBuilder.Entity<Team>()
        .ToTable("F1Teams")
        .HasComment("This table is used to store F1 teams information")
        .Property(b => b.Name)
        .HasComment("The Name of the team");

Let us see how we can ignore properties from being migrated to the database

public class Driver : BaseEntity
{
    public Guid TeamId { get; set; }
    public string Name { get; set; } = "";
    public int RacingNumber { get; set; } 
    public virtual Team Team { get; set; }

    [NotMapped]
    public string NumberAndName { get; set; }
}

public class Team : BaseEntity
{
    public Team()
    {
        Drivers = new HashSet<Driver>();
    }

    public string Name { get; set; } = "";
    public string Year { get; set; } = "";

    [NotMapped]
    public string NameAndYear { get; set; }

    public virtual ICollection<Driver> Drivers { get; set; }
}

// Or with Fluent API
modelBuilder.Entity<Driver>(entity =>
{
    entity.HasOne(d => d.Team)
        .WithMany(p => p.Drivers)
        .HasForeignKey(d => d.TeamId)
        .OnDelete(DeleteBehavior.Restrict)
        .HasConstraintName("FK_Driver_Team");

    entity.ToTable("F1Drivers");
    entity.Ignore(x => x.NumberAndName);
});

modelBuilder.Entity<Team>()
        .ToTable("F1Teams")
        .HasComment("This table is used to store F1 teams information")
        .Ignore(x => x.NameAndYear);

Update Column Name

// Fluent API
modelBuilder.Entity<Team>()
            .Property(b => b.Id)
        .HasColumnName("team_id");

public class Driver : BaseEntity
{
    public Guid TeamId { get; set; }
    public string Name { get; set; } = "";

    [Column("racing_number")]
    public int RacingNumber { get; set; } 
    public virtual Team Team { get; set; }

    [NotMapped]
    public string NumberAndName { get; set; }
}

Column Data type

// Data Annotation
public class Driver : BaseEntity
{
    public Guid TeamId { get; set; }

    [Column(TypeName = "varchar(200)")]
    public string Name { get; set; } = "";

    [Column("racing_number")]
    public int RacingNumber { get; set; } 
    public virtual Team Team { get; set; }

    [NotMapped]
    public string NumberAndName { get; set; }
}

// Fluent API
modelBuilder.Entity<Driver>(entity =>
        {
            entity.HasOne(d => d.Team)
                .WithMany(p => p.Drivers)
                .HasForeignKey(d => d.TeamId)
                .OnDelete(DeleteBehavior.Restrict)
                .HasConstraintName("FK_Driver_Team");

            entity.Property(b => b.Name).HasColumnType("varchar(200)");

            entity.ToTable("F1Drivers");
            entity.Ignore(x => x.NumberAndName);
        });

Column Order

modelBuilder.Entity<Driver>(entity =>
        {
            entity.HasOne(d => d.Team)
                .WithMany(p => p.Drivers)
                .HasForeignKey(d => d.TeamId)
                .OnDelete(DeleteBehavior.Restrict)
                .HasConstraintName("FK_Driver_Team");

            entity.Property(b => b.Name).HasColumnType("varchar(200)");

            entity.ToTable("F1Drivers");
            entity.Ignore(x => x.NumberAndName);

             entity.Property(b => b.Id)
            .HasColumnOrder(0);

            entity.Property(b => b.Name)
            .HasColumnOrder(1);

            entity.Property(b => b.RacingNumber)
            .HasColumnOrder(2);
        });

.NET 6 with PostgreSQL

Mohamad Lawand — Sun, 14 Aug 2022 08:09:46 +0000

In this article, we will be exploring how to utilise PostgreSQL with .NET 6. The steps we need need to take to setup, configure and utilise PostgreSQL with .NET 6 WebAPI.

You can watch the full video on YouTube

You can also find the source code on Github
https://github.com/mohamadlawand087/Net6-PostgreSQL

First we will be focusing on installing PostgreSQL on our machine.

Installing Postgres on your machine

brew install postgresql

Starting and Stoping Postgres is running

brew services start postgresql 
brew services stop postgresql

Connect with Postgres

psql postgres

Create User and Pass so we can utilise them in our .NET app

CREATE ROLE mohamad WITH LOGIN PASSWORD '12345678';
ALTER ROLE mohamad CREATEDB;
ALTER ROLE mohamad WITH Superuser;

Create a Database

create database sampledb;

Grand permission to the db

GRANT CONNECT ON DATABASE sampledb TO mohamad;

Installing EF tool

dotnet tool install --global dotnet-ef

Creating the .NET web application

dotnet new webapi -n DbExploration

Installing Packages

dotnet add package Npgsql.EntityFrameworkCore.PostgreSQL
dotnet add package Microsoft.EntityFrameworkCore.Design
dotnet add package Microsoft.EntityFrameworkCore.Tools

Update AppSettings with connection string

"ConnectionStrings": {
    "SampleDbConnection": "User ID =mohamad;Password=12345678;Server=localhost;Port=5432;Database=sampledb; Integrated Security=true;Pooling=true;"
  }

Let us add our db context, we create a folder called Data and inside the folder we create a class called ApiDbContext

using Microsoft.EntityFrameworkCore;

namespace DbExploration.Data;

public class ApiDbContext : DbContext
{
    public ApiDbContext(DbContextOptions<ApiDbContext> options):base(options) {  }
}

Adding connection string to Program.cs

builder.Services.AddEntityFrameworkNpgsql().AddDbContext<ApiDbContext>(opt =>
        opt.UseNpgsql(builder.Configuration.GetConnectionString("SampleDbConnection")));

Now start by adding the Models folder, inside the Models folder we will create our first Model would be a generic class called BaseEntity

public abstract class BaseEntity
{
    public Guid Id { get; set; } = Guid.NewGuid();
    public DateTime UpdatedDate { get; set; } = DateTime.UtcNow;
    public string UpdatedBy { get; set; } = "";
    public string AddedBy { get; set; } = "";
    public DateTime AddedDate { get; set; } = DateTime.UtcNow;
    public int Status { get; set; } = 1;
}

Next we will need to create a new model called Team

public class Team : BaseEntity
{
    public Team()
    {
        Drivers = new HashSet<Driver>();
    }

    public string Name { get; set; } = "";
    public string Year { get; set; } = "";

    public virtual ICollection<Driver> Drivers { get; set; }
}

Next model would be the driver

public class Driver : BaseEntity
{
    public Guid TeamId { get; set; }
    public string Name { get; set; } = "";
    public int RacingNumber { get; set; } 
    public virtual Team Team { get; set; }
}

Next model would be DriverMedia

public class DriverMedia
{
    public int Id { get; set; }
    public byte[] Media { get; set; }
    public string Caption { get; set; }

    public Guid DriverId { get; set; }
    public Driver Driver { get; set; }
}

Now we update the Db context, we will be utilising fluent API

public class ApiDbContext : DbContext
{
    public virtual DbSet<Driver> Drivers { get; set; }
    public virtual DbSet<Team> Teams { get; set; }

    public ApiDbContext(DbContextOptions<ApiDbContext> options):base(options) {  }

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


        modelBuilder.Entity<Driver>(entity =>
        {
                        // One to Many relationship
            entity.HasOne(d => d.Team)
                .WithMany(p => p.Drivers)
                .HasForeignKey(d => d.TeamId)
                .OnDelete(DeleteBehavior.Restrict)
                .HasConstraintName("FK_Driver_Team");

                        // One to One
                        entity.HasOne(d => d.DriverMedia)
                    .WithOne(i => i.Driver)
                    .HasForeignKey<DriverMedia>(b => b.DriverId);
        });


    }
}

To create the tables in the database from our .Net application we need to do the followigin

dotnet ef migrations add "initial_migrations"
dotnet ef database update

Changing Table Name in the d

.Net 6 WebAPI - Upload files to AWS S3 - Step by Step

Mohamad Lawand — Wed, 08 Jun 2022 06:34:57 +0000

In this article we will explore AWS S3 and see how we can upload files to our S3 buckets from an .NET 6 Web API.

You can watch the full video on YouTube with detail explanation of S3

You can find the link to the source code below
https://github.com/mohamadlawand087/NET6-S3

Now lets get started

The first thing we need to do is to create our application inside our terminal

dotnet new webapi -n AutoUpload

Create the classlib which is responsible for S3 communication

dotnet new classlib -n AwsS3

Add reference between the webapi and the classlib

dotnet add AutoUpload/AutoUpload.csproj reference AwsS3/AwsS3.csproj

Now we open the solution in VsCode and we delete the auto generated class inside AwsS3

and we add 2 new folders

Models
Services

We install S3 nuget package inside the AwsS3 class lib

dotnet add package AWSSDK.S3

Now inside our Models folder we need to create our S3 Model, let us add a class called S3Object

public class S3Object
{
    public string Name { get; set; } = null!;
    public MemoryStream InputStream { get; set; } = null!;
        public string BucketName { get; set; } = null!;
}

Now we need to add another class which will represent the data which is being sent back from S3 after the upload, so we will need to create a new class called S3ResponseDto

public class S3ResponseDto
{
    public int StatusCode { get; set; }
    public string Message { get; set; }
}

Now we need to another class which will be responsible for storing the AWS credentials which we will utilise to communicate with S3 bucket, so we will create a new class called AwsCredentials a

public class AwsCredentials
{
    public string AccessKey { get; set; } = "";
    public string SecretKey { get; set; } = "";
}

Now we need to add a section so we can get all of the required configuration so inside our AwsS3 classlib we will create a new folder called configurations in the root directory and inside that folder we will create a new class called Constants which represent the config values name

public class Constants
{
    public static string AccessKey = "AccessKey";
    public static string SecretKey = "SecretKey";
}

Now inside our service folder we will add a new interface call IStorageService

using AwsS3.Models;
using AwsS3.Models.DTO;

namespace AwsS3.Services;

public interface IStorageService
{
    Task<S3ResponseDto> UploadFileAsync(S3Object obj, AwsCredentials awsCredentialsValues);
}

Now we need to create the service, so we create a new class called StorageService inside the Services folder

using AwsS3.Models;
using AwsS3.Models.DTO;
using Amazon.S3;
using Amazon.S3.Transfer;
using AwsS3.Configurations;
using Amazon.Runtime;

namespace AwsS3.Services;

public class StorageService : IStorageService
{
    //private readonly IConfigurationManager _config;

    public StorageService(IConfigurationManager config)
    {
        //_config = config;
    }

    public async Task<S3ResponseDto> UploadFileAsync(S3Object obj, AwsCredentials awsCredentialsValues)
    {
        //var awsCredentialsValues = _config.ReadS3Credentials();

        Console.WriteLine($"Key: {awsCredentialsValues.AccessKey}, Secret: {awsCredentialsValues.SecretKey}");

        var credentials = new BasicAWSCredentials(awsCredentialsValues.AccessKey, awsCredentialsValues.SecretKey);

        var config = new AmazonS3Config() 
        {
            RegionEndpoint = Amazon.RegionEndpoint.EUWest2
        };

        var response = new S3ResponseDto();
        try
        {
            var uploadRequest = new TransferUtilityUploadRequest()
            {
                InputStream = obj.InputStream,
                Key = obj.Name,
                BucketName = obj.BucketName,
                CannedACL = S3CannedACL.NoACL
            };

            // initialise client
            using var client = new AmazonS3Client(credentials, config);

            // initialise the transfer/upload tools
            var transferUtility = new TransferUtility(client);

            // initiate the file upload
            await transferUtility.UploadAsync(uploadRequest);

            response.StatusCode = 201;
            response.Message = $"{obj.Name} has been uploaded sucessfully";
        }
        catch(AmazonS3Exception s3Ex)
        {
            response.StatusCode = (int)s3Ex.StatusCode;
            response.Message = s3Ex.Message;
        }
        catch(Exception ex)
        {
            response.StatusCode = 500;
            response.Message = ex.Message;
        }

        return response;
    }
}

Now we need to go to our API and update our appsettings.json

"AwsConfiguration": {
    "AWSAccessKey": "ACCESSKEYID",
    "AWSSecretKey": "SECRETKEY"
  }

Next we need to update our controller

using AwsS3.Models;
using AwsS3.Services;
using Microsoft.AspNetCore.Mvc;

namespace AutoUpload.Controllers;

[ApiController]
[Route("[controller]")]
public class WeatherForecastController : ControllerBase
{

    private readonly IStorageService _storageService;
    private readonly IConfiguration _config;
    private readonly ILogger<WeatherForecastController> _logger;

    public WeatherForecastController(
        ILogger<WeatherForecastController> logger,
        IConfiguration config,
        IStorageService storageService)
    {
        _logger = logger;
        _config = config;
        _storageService = storageService;
    }

    [HttpPost(Name = "UploadFile")]

    public async Task<IActionResult> UploadFile(IFormFile file)
    {
        // Process file
        await using var memoryStream = new MemoryStream();
        await file.CopyToAsync(memoryStream);

        var fileExt = Path.GetExtension(file.FileName);
        var docName = $"{Guid.NewGuid}.{fileExt}";
        // call server

        var s3Obj = new S3Object() {
            BucketName = "live-demo-bucket821",
            InputStream = memoryStream,
            Name = docName
        };

        var cred = new AwsCredentials() {
            AccessKey = _config["AwsConfiguration:AWSAccessKey"],
            SecretKey = _config["AwsConfiguration:AWSSecretKey"]
        };

        var result = await _storageService.UploadFileAsync(s3Obj, cred);
        // 
       return Ok(result);

    }
}

Please comment your questions below

.Net 7 (Preview 4) - Minimal API - Multiple Result Type - Route Groups

Mohamad Lawand — Sun, 29 May 2022 10:16:11 +0000

In this article we will discover more feature which are coming to .Net 7 with Minimal API

The points we are going to cover today

Return multiple result types from minimal APIs
A self-documenting Todos API
Route Groups

You can watch the full video on YouTube

You can find the full source code on github
https://github.com/mohamadlawand087/Net7-MinimalApi-RouteGroup-MultipleResultType

We are going to continue working on the project from last article where we implemented filters on Minimal Api you can find the article here

https://dev.to/moe23/net-7-preview-4-minimal-api-filters-1812/

Starting project GitHub

https://github.com/mohamadlawand087/Net7-MinimalApi-Filters

Once we check out we will start refactoring our app to utilise the latest features within .Net 7 preview 4

The first item we will do is refactor our existing application, the first part will be the refactoring of our Todo CRUD operation

static class TodoApiV1
{
        // Static method to integrate with the .Net middleware 
        // Build the end route to integrate the different endpoints
    public static IEndpointRouteBuilder MapTodoApi(this IEndpointRouteBuilder routes)
    {
        routes.MapGet("/v1/items", GetAllItems);
        routes.MapGet("/v1/items/{id}", GetItem);
        routes.MapPost("/v1/items", CreateItem).AddFilter<ValidationFilter<Item>>();
        routes.MapPut("/v1/items/{id}", UpdateItem).AddFilter<ValidationFilter<Item>>();
        return routes;
    }

        // Get All Items
    public static async Task<Ok<List<Item>>> GetAllItems(ApiDbContext db)
    {
        return TypedResults.Ok(await db.Items.ToListAsync());
    }

        // Get a single item
    public static async Task<Results<Ok<Item>, NotFound>> GetItem(int id, ApiDbContext db)
    {
         return await db.Items.FirstOrDefaultAsync(x => x.Id == id) is Item item
         ? TypedResults.Ok(item)
         : TypedResults.NotFound();  
    }

        // Create a new item
    public static async Task<Results<Created<Item>, BadRequest>> CreateItem(Item item, ApiDbContext db)
    {
        if (await db.Items.FirstOrDefaultAsync(x => x.Id == item.Id) != null)
        {
            return TypedResults.BadRequest();
        }

        db.Items.Add(item);
        await db.SaveChangesAsync();
        return TypedResults.Created($"/Items/{item.Id}", item);
    }

        // Update the item
    public static async Task<Results<NoContent, NotFound>> UpdateItem(Item item, int id, ApiDbContext db)
    {
        var existItem = await db.Items.FirstOrDefaultAsync(x => x.Id == id);
        if(existItem == null)
        {
            return TypedResults.NotFound();
        }

        existItem.Title = item.Title;
        existItem.IsCompleted = item.IsCompleted;

        await db.SaveChangesAsync();
        return TypedResults.NoContent();
    }
}

Now we need to update the authentication mechanism

static class TodoAuthentication
{
    public static IEndpointRouteBuilder MapAuthenticationAPi(this IEndpointRouteBuilder routes)
    {
        routes.MapPost("/v1/accounts/login", Login);
        return routes;
    }

    public static async Task<Results<Ok<string>, UnauthorizedHttpResult>> Login(UserDto user, IConfiguration _config)
    {
        if(user.username == "admin@mohamadlawand.com" && user.password == "Password123")
        {
            var secureKey = Encoding.UTF8.GetBytes(_config["Jwt:Key"]);

            var issuer = _config["Jwt:Issuer"];
            var audience = _config["Jwt:Audience"];
            var securityKey = new SymmetricSecurityKey(secureKey);
            var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha512);

            var jwtTokenHandler = new JwtSecurityTokenHandler();

            var tokenDescriptor = new SecurityTokenDescriptor
            {
                Subject = new ClaimsIdentity(new [] {
                    new Claim("Id", "1"),
                    new Claim(JwtRegisteredClaimNames.Sub, user.username),
                    new Claim(JwtRegisteredClaimNames.Email, user.username),
                    new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
                }),
                Expires = DateTime.Now.AddMinutes(5),
                Audience = audience,
                Issuer = issuer,
                SigningCredentials = credentials
            };

            var token = jwtTokenHandler.CreateToken(tokenDescriptor);
            var jwtToken = jwtTokenHandler.WriteToken(token);
            return TypedResults.Ok(jwtToken);  
        }

        return TypedResults.Unauthorized();
    }

}

Once we have updated both we need to inform our middleware about these new endpoints

app.MapTodoApi();
app.MapAuthenticationAPi();

Next we need to enable Authorisation on the endpoints

public static IEndpointRouteBuilder MapTodoApi(this IEndpointRouteBuilder routes)
{
    routes.MapGet("/v1/items", GetAllItems).RequireAuthorization();
    routes.MapGet("/v1/items/{id}", GetItem).RequireAuthorization();
    routes.MapPost("/v1/items", CreateItem)
                .AddFilter<ValidationFilter<Item>>()
                .RequireAuthorization();
    routes.MapPut("/v1/items/{id}", UpdateItem)
                .AddFilter<ValidationFilter<Item>>()
                .RequireAuthorization();
    return routes;
}

Now we are going to enable route grouping for our endpoint, the first item we need to update the middleware integration to the following

app.MapGroup("/v1").MapTodoApi();
app.MapGroup("/v1").MapAuthenticationAPi();

Next we update the Endpoint mapping for both our Todo and our Authorisation to the following

// Todo
public static GroupRouteBuilder MapTodoApi(this GroupRouteBuilder routes)
{
    routes.MapGet("/items", GetAllItems);
    routes.MapGet("/items/{id}", GetItem);
    routes.MapPost("/items", CreateItem)
                .AddFilter<ValidationFilter<Item>>();
    routes.MapPut("/items/{id}", UpdateItem)
                .AddFilter<ValidationFilter<Item>>();
    return routes;
}

// Authorisation
public static IEndpointRouteBuilder MapAuthenticationAPi(this IEndpointRouteBuilder routes)
{
    routes.MapPost("/accounts/login", Login);
    return routes;
}

Let us update our middleware

app.MapGroup("/v1").RequireAuthorization().MapCrudTodoApi();
app.MapGroup("/v1").MapAuthenticationForApi();

For any questions please comment down below

.Net 7 (Preview 4) - Minimal API Filters

Mohamad Lawand — Fri, 20 May 2022 13:50:30 +0000

In this article we will implement one of the new features introduced with .Net 7 Preview 4 which is Filtering with Minimal API

You can watch the full video on YouTube

To start we will need our repository which is a Minimal API which we created in .NET 6

Get .NET 7 Preview SDK

https://dotnet.microsoft.com/en-us/download/dotnet/7.0

Get the repository

https://github.com/mohamadlawand087/MinimalApi-JWT

The first thing we need to do is update our application to .Net 7 Preview 4, we open our TodoApi.csproj and replace it with the following

<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>net7.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
    <LangVersion>preview</LangVersion>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="7.0.0-preview.4.22229.2" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="7.0.0-preview.4.22229.2">
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
      <PrivateAssets>all</PrivateAssets>
    </PackageReference>
    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="7.0.0-preview.4.22229.2" />
    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.2.3" />
  </ItemGroup>

</Project>

We can see from the updated code that we have utilised the .Net 7 framework as well enabled C# 11 feature by using the lang version preview and we have updated all of the nuget packages to the latest version

Once that is done, lets run our application to make sure everything is running as it should

dotnet run

Let us now implement filter to our post method inside our program.cs

app.MapPost("/items",  [Authorize] async (ApiDbContext db, Item item) => {
    if( await db.Items.FirstOrDefaultAsync(x => x.Id == item.Id) != null)
    {
        return Results.BadRequest();
    }

    db.Items.Add(item);
    await db.SaveChangesAsync();
    return Results.Created( $"/Items/{item.Id}",item);
}).AddFilter((ctx, next) => async (context) =>
{
    return  CheckIncomingObj(context)  == false ? Results.BadRequest("Invalid parameters") : await next(context);
});

bool? CheckIncomingObj(RouteHandlerInvocationContext context) 
{
    if (context.Parameters[1] == null) 
        return false;

    if (context.Parameters[1] is not Item param)
        return false;

    return IsValidItem(param);
}

bool IsValidItem(Item item)
{
    if (item.Title.Length > 1 && item.Id > 0)
        return true;

    return false;
}

Now lets make these validation more generic

Let us create a new folder called Filters in the root directory and inside the folder will create a new class class ValidationFilters.cs

namespace TodoApi.Filters;

public class ValidationFilter<T> : IRouteHandlerFilter where T : class
{

    public async ValueTask<object?> InvokeAsync(RouteHandlerInvocationContext context, RouteHandlerFilterDelegate next)
    {
        var param = context.Parameters.FirstOrDefault(x => x?.GetType() == typeof(T));

        if(param is null)
        {
            return Results.BadRequest();
        }

        if (param is Item)
        {
            var validationResult = IsValidItem(param as Item);

            if(!validationResult)
            {
                return Results.BadRequest("Invalid parameters.");
            }
        }

        // before the endpoint call
        var result = await next(context);

        // after endpoint call
        return result;
    }

    bool IsValidItem(Item? item)
    {
        if (item == null)
            return false;

        if (item.Title.Length > 1 && item.Id > 0)
            return true;

        return false;
    }
}

And now let us update our post method in the program.cs

app.MapPost("/items", [Authorize] async (ApiDbContext db, Item item) =>
{
    if (await db.Items.FirstOrDefaultAsync(x => x.Id == item.Id) != null)
    {
        return Results.BadRequest();
    }

    db.Items.Add(item);
    await db.SaveChangesAsync();
    return Results.Created($"/Items/{item.Id}", item);
}).AddFilter<ValidationFilter<Item>>();

Please ask any questions or clarification you might need.