Forem: Gaurav

🚀 Getting Started with RabbitMQ Pub/Sub using MassTransit in .NET

Gaurav — Wed, 21 May 2025 15:23:26 +0000

In this guide, we’ll set up a Publisher/Consumer architecture using RabbitMQ and MassTransit in .NET. We’ll cover:

Docker setup for RabbitMQ
Publisher configuration in ASP.NET Core
Consumer setup in a .NET Console App
Sending and receiving messages

🐳 Step 1: Run RabbitMQ in Docker
Create a file named docker-compose.yml with the following content:

version: '3'
services:
  rabbitmq:
    image: rabbitmq:3-management
    container_name: rabbitmq
    ports:
      - "5672:5672"
      - "15672:15672"
    environment:
      RABBITMQ_DEFAULT_USER: guest
      RABBITMQ_DEFAULT_PASS: guest

Then run:

docker-compose up -d

✅ RabbitMQ Management UI: http://localhost:15672
Username: guest
Password: guest

📆 Step 2: Create the Shared Event Model

This model will be shared between publisher and consumer:

namespace Response.EventModel;

public class EventModel
{
    public string message { get; set; }
}

📨 Step 3: Setup the Publisher in ASP.NET Core

🔹 Add NuGet Packages

<PackageReference Include="MassTransit" Version="8.4.1" />
<PackageReference Include="MassTransit.RabbitMQ" Version="8.4.1" />

🔹 Create the Publisher Class

using MassTransit;
using Response.EventModel;

namespace TechnicianAdmin.Event;

public class Publisher
{
    private readonly IPublishEndpoint _publishEndpoint;

    public Publisher(IPublishEndpoint publishEndpoint)
    {
        _publishEndpoint = publishEndpoint;
    }

    public async Task PublishMessage()
    {
        var message = new EventModel
        {
            message = "Hey this is testing message from publisher"
        };

        await _publishEndpoint.Publish(message);
    }
}

🔹 Register MassTransit in Dependency Injection

using MassTransit;
using TechnicianAdmin.Event;

public static class AddMassTransitConfiguration
{
    public static IServiceCollection MassTransitConfiguration(this IServiceCollection services)
    {
        services.AddTransient<Publisher>();

        services.AddMassTransit(x =>
        {
            x.SetKebabCaseEndpointNameFormatter();

            // Auto-discover consumers in the assembly (optional)
            x.AddConsumers(typeof(Program).Assembly);

            x.UsingRabbitMq((context, cfg) =>
            {
                cfg.Host("localhost", "/", h =>
                {
                    h.Username("guest");
                    h.Password("guest");
                });

                cfg.ConfigureEndpoints(context);
            });
        });

        return services;
    }
}

🔹 Inject and Use Publisher in Controller

private readonly Publisher _publishEndpoint;

public Controller(Publisher publishEndpoint)
{
    _publishEndpoint = publishEndpoint;
}

[AllowAnonymous]
[HttpGet("publish-rabbitMQ-message")]
public async Task<IActionResult> SendMessage()
{
    await _publishEndpoint.PublishMessage();
    return Ok("Message sent to RabbitMQ");
}

🗒️ Step 4: Setup the Consumer in a .NET Console App

🔹 Add NuGet Packages

<PackageReference Include="MassTransit.RabbitMQ" Version="8.4.1" />
<PackageReference Include="Microsoft.Extensions.Hosting" Version="9.0.5" />
<PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="9.0.5" />
<PackageReference Include="RabbitMQ.Client" Version="7.1.2" />

🔹 Create the EventModel Again (or Share It via Class Library)

namespace Response.EventModel;

public class EventModel
{
    public string message { get; set; }
}

🔹 Create the Consumer

using MassTransit;
using Response.EventModel;

namespace ConsoleApp1;

public class HelloMessageConsumer : IConsumer<EventModel>
{
    public Task Consume(ConsumeContext<EventModel> context)
    {
        Console.WriteLine($"Received message: {context.Message.message}");
        return Task.CompletedTask;
    }
}

🔹 Setup MassTransit in Program.cs

using ConsoleApp1;
using MassTransit;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

var builder = Host.CreateDefaultBuilder(args);

builder.ConfigureServices((hostContext, services) =>
{
    services.AddMassTransit(x =>
    {
        x.AddConsumer<HelloMessageConsumer>();

        x.UsingRabbitMq((context, cfg) =>
        {
            cfg.Host("localhost", "/", h =>
            {
                h.Username("guest");
                h.Password("guest");
            });

            cfg.ReceiveEndpoint("hello-message-queue", e =>
            {
                e.ConfigureConsumer<HelloMessageConsumer>(context);
            });
        });
    });
});

await builder.Build().RunAsync();

✅ Test the Flow

Make sure RabbitMQ is running via Docker.
Run the consumer app.
Hit the API endpoint:GET http://localhost:/publish-rabbitMQ-message
You should see output like:

Received message: Hey this is testing message from publisher

🧠 Conclusion

Congrats! 🎉 You’ve successfully:

Set up RabbitMQ using Docker
Published a message via ASP.NET Core
Consumed it via a .NET Console App This pattern forms the foundation of microservices-based communication using MassTransit + RabbitMQ in the .NET ecosystem.

Custom Middleware Extensions in .NET Core Web API

Gaurav — Thu, 09 Jan 2025 18:09:44 +0000

Middleware in ASP.NET Core is a powerful mechanism for intercepting HTTP requests and responses during their lifecycle. With custom middleware, developers can handle tasks such as logging, exception handling, and authorization in a structured and reusable manner. This blog post will guide you through creating and extending middleware in ASP.NET Core, leveraging extension methods for improved modularity and readability.

What is Middleware?

Middleware is software injected into the request-response pipeline in ASP.NET Core applications. It processes HTTP requests as they flow through the pipeline, allowing developers to manipulate them before they reach the endpoint or after the endpoint has processed them.

Why Use Custom Middleware?
Centralizes logic like logging, error handling, and security checks.
Enhances maintainability by keeping concerns separate.
Simplifies reusability and testing.

Make sure you have the required package installed:

dotnet add package Microsoft.Extensions.DependencyInjection.Abstractions

Step 1: Setting Up Middleware Extension Methods
We define a static class MiddlewareExtensions to house all our middleware extension methods:

namespace gaurav.Middleware;

public static class MiddlewareExtensions
{
    public static IApplicationBuilder UseAuthorizationMiddleware(this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<AuthorizationMiddleware>();
    }

    public static IApplicationBuilder UseExceptionMiddleware(this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<ExceptionMiddleware>();
    }

    public static IApplicationBuilder UseLoggingMiddleware(this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<LoggingMiddleware>();
    }
}

Each method is a thin wrapper around UseMiddleware, ensuring that the middleware can be registered in the startup pipeline succinctly.

Step 2: Building the Middleware Classes

1. Authorization Middleware
This middleware handles authorization checks, ensuring that only authenticated users can access protected resources.

namespace gaurav.Middleware;

public class AuthorizationMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<AuthorizationMiddleware> _logger;

    public AuthorizationMiddleware(RequestDelegate next, ILogger<AuthorizationMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }

    public async Task InvokeAsync(HttpContext context, ISQLORMService sqlOrmService)
    {
        _logger.LogInformation("Processing authorization...");
        // Implement authorization logic here
        await _next(context);
    }
}

2. Exception Middleware
This middleware provides a unified way to handle exceptions, log them, and return meaningful error responses to clients.

namespace gaurav.Middleware;

public class ExceptionMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context, ILogger<ExceptionMiddleware> logger)
    {
        try
        {
            await _next(context);
        }
        catch (Exception ex)
        {
            logger.LogError($"Unhandled exception: {ex}");
            await HandleExceptionAsync(context, ex, Guid.NewGuid().ToString());
        }
    }

    private async Task HandleExceptionAsync(HttpContext context, Exception exception, string traceId)
    {
        context.Response.ContentType = "application/json";
        context.Response.StatusCode = StatusCodes.Status500InternalServerError;

        await context.Response.WriteAsync(new
        {
            statusCode = context.Response.StatusCode,
            message = exception.Message,
            traceId
        }.ToString());
    }
}

3. Logging Middleware
This middleware logs incoming requests and outgoing responses, providing valuable insights into the application's operation.

namespace gaurav.Middleware;

public class LoggingMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context, ILogger<LoggingMiddleware> logger)
    {
        context.Request.EnableBuffering();
        logger.LogInformation($"Incoming request: {context.Request.Method} {context.Request.Path}");

        await _next(context);

        logger.LogInformation($"Outgoing response: {context.Response.StatusCode}");
    }
}

Step 3: Configuring Middleware in the Pipeline
To register custom middleware in the HTTP pipeline, use the extension methods in the Program.cs or Startup.cs file.

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.UseLoggingMiddleware();
app.UseExceptionMiddleware();
app.UseAuthorizationMiddleware();

app.MapControllers();
app.Run();

Benefits of Middleware Extensions

Readability: Extension methods make pipeline configuration intuitive.
Reusability: Middleware can be reused across multiple applications.
Separation of Concerns: Each middleware handles a specific responsibility.

Conclusion

Custom middleware with extension methods streamlines your application's HTTP request pipeline. This approach not only enhances code readability but also aligns with the best practices of modular application design. By incorporating middlewares like logging, exception handling, and authorization, you can build robust and maintainable ASP.NET Core applications.

Feel free to extend this concept further with caching, rate-limiting, or custom headers as middleware!

Let me know in the comments how you use middleware in your projects or what custom middleware ideas you have! 🚀

Dependency Injection in ASP.NET Core with Extension Classes: A Comprehensive Guide

Gaurav — Thu, 09 Jan 2025 03:04:29 +0000

Dependency Injection (DI) is a fundamental design pattern in ASP.NET Core that promotes code reusability, maintainability, and testability. One of the best practices for organizing DI in large applications is to encapsulate service registrations using extension classes. This blog post will guide you through the use of DI with extension classes, using the provided example code for a hands-on understanding.

What is Dependency Injection?

Dependency Injection is a design pattern used to achieve Inversion of Control (IoC) between classes and their dependencies. Instead of instantiating objects directly within a class, dependencies are injected, typically during runtime. This makes the application more modular and easier to test.

Benefits of Using Extension Classes for DI

Separation of Concerns: Keeps the Program.cs or Startup.cs clean and manageable.
Reusability: Allows encapsulation of DI logic for reuse across projects.
Maintainability: Changes to service registrations can be made in one place without cluttering the main application configuration.

Example: Dependency Injection Using an Extension Class

Here’s a complete example of using an extension class for DI in ASP.NET Core.

1. Add the Required NuGet Package
Make sure you have the required package installed:

dotnet add package Microsoft.Extensions.DependencyInjection.Abstractions

2. Creating the Extension Class
The extension class encapsulates service registrations for better organization. Below is a class named AddDependencyInjection in the DependencyInjection namespace:

using Microsoft.Extensions.DependencyInjection;
using dumdum.Interface;
using dumdum.Model.DB;
using dumdum.Service.Implementation;
using dumdum.Service.Interface;
using Sieve.Services;
using Microsoft.EntityFrameworkCore;
using Microsoft.OpenApi.Models;
using System.Text;
using Microsoft.IdentityModel.Tokens;

namespace dumdum.DependencyInjection
{
    public static class AddDependencyInjection
    {
        public static IServiceCollection AddDependencies(this IServiceCollection services)
        {
            // Database Context
            services.AddDbContext<Context>(options =>
                options.UseSqlServer(Environment.GetEnvironmentVariable("CodeXMinioService")));

            // General Services
            services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
            services.AddScoped(typeof(IGenericRepository<>), typeof(GenericRepository<>));
            services.AddScoped<IUnitOfWork, UnitOfWork>();
            services.AddScoped(typeof(IBaseService<,>), typeof(BaseService<,>));
            services.AddScoped<ISieveProcessor, SieveProcessor>();
            services.AddScoped<ISQLORMService, DapperORMService>();

            // Business Logic Services
            services.AddScoped<IUploadService, UploadService>();
            services.AddScoped<IUserMaster, UserMasterService>();

            // JWT Authentication
            services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
                .AddJwtBearer(options =>
                {
                    options.TokenValidationParameters = new TokenValidationParameters
                    {
                        ValidateIssuerSigningKey = true,
                        IssuerSigningKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes("your_secret_key_here")),
                        ValidateIssuer = false,
                        ValidateAudience = false,
                        ValidateLifetime = true,
                        ClockSkew = TimeSpan.Zero
                    };
                });

            return services;
        }
    }
}

3. Using the Extension Method in Program.cs
With the extension class in place, the DI registrations can be easily included in the main entry point of your application:

using dumdum.DependencyInjection;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllers();

builder.Services.AddDependencies(); // Adding dependencies via extension method

builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure the middleware pipeline
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

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

app.MapControllers();
app.Run();

Key Points in the Example

Encapsulation of Services: All the service registrations are encapsulated in the AddDependencies method, promoting reusability and maintainability.
Modular Approach: Each type of service (e.g., DbContext, repositories, business logic services) is grouped logically.
JWT Authentication: Secure your API by configuring AddJwtBearer with token validation parameters.

Benefits of the Approach

Scalability: Easily add more services to the extension method as your application grows.
Code Organization: Keeps DI logic separate from application startup code.
Testability: Simplifies unit testing by providing a centralized place to mock services.

Conclusion

Using extension methods for dependency injection is a best practice in ASP.NET Core that enhances code modularity and readability. By encapsulating service registrations in an extension class, you can keep your main application file clean while making the DI setup reusable and easy to maintain.

Adopting this pattern in your projects will lead to more structured and professional code. Happy coding! 🚀

Connect with me:@LinkedIn

Securing Your .NET APIs with JWT Authentication

Gaurav — Fri, 03 Jan 2025 02:13:21 +0000

JSON Web Tokens (JWT) are a widely-used standard for securing APIs. In this post, we will explore how to implement JWT authentication in a .NET application, including generating tokens, configuring authentication middleware, and enabling Swagger to accept tokens for testing.

1. Prerequisites

Before we begin, ensure your .NET project includes the following:

ASP.NET Core
NuGet Packages:

dotnet add package Microsoft.AspNetCore.Authentication.JwtBearer
dotnet add package Swashbuckle.AspNetCore

2. Generate JWT Tokens

Add a Login endpoint to generate JWT tokens for authenticated users. Below is the implementation:

public async Task<ActionResult> Login(string email, string password)
{
    var _user = _db.UserMaster.FirstOrDefault(x => x.Email == email && x.Password == password && x.IsDeleted == false);
    if (_user == null)
    {
        return new BadRequestObjectResult("UnAuthorized");
    }

    // JWT Token generation
    var tokenHandler = new JwtSecurityTokenHandler();
    var key = Encoding.ASCII.GetBytes("sdf5s4f6sd54fsdfsdf"); // Use a secure key and store it safely.
    var tokenDescriptor = new SecurityTokenDescriptor
    {
        Subject = new ClaimsIdentity(new Claim[]
        {
            new Claim(ClaimTypes.Name, _user.Id.ToString()),
            new Claim(ClaimTypes.Email, _user.Email)
        }),
        Expires = DateTime.UtcNow.AddHours(1),
        SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
    };

    var token = tokenHandler.CreateToken(tokenDescriptor);
    var tokenString = tokenHandler.WriteToken(token);

    return new OkObjectResult(new
    {
        Token = tokenString,
        ExpiresIn = tokenDescriptor.Expires
    });
}

Key Points:

Validate the user credentials (e.g., email and password).
Generate a secure JWT token with claims.
Return the token to the client.

3. Configure JWT Authentication Middleware

Add JWT authentication middleware in your Program.cs or Startup.cs:

builder.Services.AddAuthentication(Microsoft.AspNetCore.Authentication.JwtBearer.JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new Microsoft.IdentityModel.Tokens.TokenValidationParameters
        {
            ValidateIssuerSigningKey = true,
            IssuerSigningKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes("sdf5s4f6sd54fsdfsdf")),
            ValidateIssuer = false,
            ValidateAudience = false,
            ValidateLifetime = true,
            ClockSkew = TimeSpan.Zero
        };

        options.Events = new JwtBearerEvents
        {
            OnAuthenticationFailed = context =>
            {
                context.Response.StatusCode = 401;
                context.Response.ContentType = "application/json";
                return context.Response.WriteAsync(JsonConvert.SerializeObject(new { Message = "Authentication Failed" }));
            },
            OnChallenge = context =>
            {
                context.HandleResponse();
                context.Response.StatusCode = 401;
                context.Response.ContentType = "application/json";
                return context.Response.WriteAsync(JsonConvert.SerializeObject(new { Message = "Token is missing or invalid" }));
            }
        };
    });

Key Points:

Validate the token's signature, expiration, and audience.
Handle authentication errors gracefully.

4. Secure API Endpoints

Use the [Authorize] attribute to secure your endpoints:

[Authorize]
[HttpGet("secure-endpoint")]
public IActionResult SecureEndpoint()
{
    return Ok("This is a secure endpoint!");
}

Key Points:

Ensure all sensitive endpoints are protected with [Authorize].
Add role-based authorization if needed.

5. Enable Swagger to Accept JWT Tokens

Add Swagger support for JWT authentication:

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

    c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
    {
        Name = "Authorization",
        Type = SecuritySchemeType.ApiKey,
        Scheme = "Bearer",
        BearerFormat = "JWT",
        In = ParameterLocation.Header,
        Description = "Enter 'Bearer' [space] and then your token in the text input below.\nExample: \"Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9\""
    });

    c.AddSecurityRequirement(new OpenApiSecurityRequirement
    {
        {
            new OpenApiSecurityScheme
            {
                Reference = new OpenApiReference
                {
                    Type = ReferenceType.SecurityScheme,
                    Id = "Bearer"
                }
            },
            Array.Empty<string>()
        }
    });
});

Key Points:

Add a Bearer Token input field in Swagger.
Click the Authorize button in Swagger to authenticate.

6. Test the Implementation

Generate a token using the Login endpoint.
Use Swagger or Postman to send requests to secured endpoints with the token in the Authorization header.

Example Header:

Authorization: Bearer <your_token_here>

7. Conclusion

By following these steps, you have successfully implemented JWT authentication in your .NET application. Your APIs are now secured, and Swagger provides an easy way to test the protected endpoints.

Connect with me:@LinkedIn

.NET Core MVC Project Structure : Implementing a Generic Service and Repository Pattern

Gaurav — Tue, 03 Dec 2024 15:15:37 +0000

In this post, we'll dive into how the Unit of Work and Repository Pattern simplify database access in .NET Core MVC applications. These patterns promote clean architecture, reusability, and a clear separation of concerns. Let's explore their implementation through an example using BaseService, GenericRepository, and UnitOfWork with a UserMasterService.

Why Use the Repository and Unit of Work Pattern?
Repository Pattern: Encapsulates data access logic, keeping it clean and isolated. It serves as a mediator between the data access layer and the business logic layer.
Unit of Work Pattern: Ensures consistency across multiple repositories during transactions. By grouping operations under a single transaction, it simplifies error handling and rollback processes.

Repository Pattern: Encapsulates data access logic, making the codebase cleaner and easier to maintain.
Unit of Work Pattern: Ensures consistency across transactions by coordinating changes to multiple repositories.

1. BaseService

Purpose: A generic service layer that provides CRUD operations for any entity type inheriting from AuditableEntity. This promotes code reuse and consistency across the application.

Key Methods:

Create: Adds a new entity to the database. If the entity is AuditableEntity, it automatically sets audit properties like creation date.
Retrieve: Fetches all records for an entity type from the database with AsNoTracking for better performance on read-only queries.
RetrieveByID: Retrieves a single entity by its ID using the repository.
Update: Finds an existing entity by ID, updates its properties, and saves changes.
Delete: Performs a soft delete by setting the IsDeleted flag, ensuring data is not permanently removed.

using manage_my_assets.App;
using manage_my_assets.Models;
using manage_my_assets.Service.Interface;
using Microsoft.EntityFrameworkCore;
using System.Threading.Tasks;

namespace manage_my_assets.Service.Implementation
{
    public class BaseService<T> : IBaseService<T> where T : AuditableEntity
    {
        private readonly IUnitOfWork _unitOfWork;
        private readonly AppDbContext _dbContext;

        public BaseService(AppDbContext dbContext, IUnitOfWork unitOfWork)
        {
            _dbContext = dbContext;
            _unitOfWork = unitOfWork;
        }

        public async Task<T> Create(T entity)
        {
            if (entity is AuditableEntity auditableEntity)
            {
                auditableEntity.SetAuditableProperties();
            }

            await _unitOfWork.Repository<T>().Insert(entity);
            await _unitOfWork.SaveChangesAsync();
            return entity;
        }

        public async Task<bool> Delete(int id)
        {
            var entity = await _unitOfWork.Repository<T>().GetById(id);
            if (entity == null) return false;

            _unitOfWork.Repository<T>().Delete(entity);
            await _unitOfWork.SaveChangesAsync();
            return true;
        }

        public async Task<List<T>> Retrieve()
        {
            return await _dbContext.Set<T>().AsNoTracking().ToListAsync();
        }

        public async Task<T> RetrieveByID(int id)
        {
            return await _unitOfWork.Repository<T>().GetById(id);
        }

        public async Task<T> Update(int id, T entity)
        {
            var existingEntity = await _unitOfWork.Repository<T>().GetById(id);
            if (existingEntity == null) return null;

            if (existingEntity is AuditableEntity auditableEntity)
            {
                auditableEntity.UpdateAuditableProperties();
            }

            // Assuming a method to update entity properties from the provided entity
            _unitOfWork.Repository<T>().Update(existingEntity);
            await _unitOfWork.SaveChangesAsync();

            return existingEntity;
        }
    }
}

2. GenericRepository

Purpose: A reusable repository that handles data access operations such as Insert, Update, Delete, and GetAll for any entity.

CRUD Operations:

GetAll: Fetches all non-deleted records.
Insert: Adds a new entity to the database.
Update: Updates an entity’s state in the database.
GetById: Retrieves an entity by ID, ensuring it hasn’t been soft deleted.

using manage_my_assets.App;
using manage_my_assets.Models;
using manage_my_assets.Service.Interface;
using Microsoft.EntityFrameworkCore;

namespace manage_my_assets.Service.Implementation
{
    public class GenericRepository<T> : IGenericRepository<T> where T : AuditableEntity
    {
        protected readonly AppDbContext _dbContext;

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

        public T Delete(T entity)
        {
            //_dbContext.Set<T>().Remove(entity); //hard delete
            entity.IsDeleted = true; //soft delete
            _dbContext.Set<T>().Update(entity);
            return entity;
        }

        public async Task<IEnumerable<T>> GetAll()
        {
            return await _dbContext.Set<T>().Where(x => x.IsDeleted == false).ToListAsync();
        }

        public async Task<T> GetById(int id)
        {
            var response = await _dbContext.Set<T>().FindAsync(id);
            if (response.IsDeleted) //check for soft delete
                return null;
            return response;
        }

        public async Task<T> Insert(T entity)
        {
            var res = typeof(T);

            await _dbContext.Set<T>().AddAsync(entity);
            return entity;
        }

        public T Update(T entity)
        {
            _dbContext.Set<T>().Update(entity);
            return entity;
        }
    }
}

3. UnitOfWork

Purpose: Orchestrates transactions across multiple repositories, ensuring a consistent and reliable database state.

using manage_my_assets.App;
using manage_my_assets.Models;
using manage_my_assets.Service.Interface;

namespace manage_my_assets.Service.Implementation
{
    public class UnitOfWork : IUnitOfWork
    {
        protected readonly AppDbContext _dbContext;
        private readonly IDictionary<Type, dynamic> _repositories;

        public UnitOfWork(AppDbContext dbContext)
        {
            _repositories = new Dictionary<Type, dynamic>();
            _dbContext = dbContext;
        }

        public IGenericRepository<T> Repository<T>() where T : AuditableEntity
        {
            var entityType = typeof(T);

            if (_repositories.ContainsKey(entityType))
            {
                return _repositories[entityType];
            }

            var repositoryType = typeof(GenericRepository<>);

            var repository = Activator.CreateInstance(repositoryType.MakeGenericType(typeof(T)), _dbContext);

            if (repository == null)
            {
                throw new NullReferenceException("Repository should not be null");
            }

            _repositories.Add(entityType, repository);

            return (IGenericRepository<T>)repository;
        }

        public async Task<int> SaveChangesAsync()
        {
            return await _dbContext.SaveChangesAsync();
        }

        public async Task RollBackChangesAsync()
        {
            await _dbContext.Database.RollbackTransactionAsync();
        }


    }
}

Dependency Injection in Program.cs

using manage_my_assets.App;
using manage_my_assets.Service.Implementation;
using manage_my_assets.Service.Interface;
using Microsoft.AspNetCore.Authentication.Cookies;
using Microsoft.EntityFrameworkCore;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllersWithViews();

builder.Services.AddDbContext<AppDbContext>(x=>x.UseSqlServer(builder.Configuration.GetConnectionString("ManagerConnectionString")));

builder.Services.AddScoped(typeof(IGenericRepository<>), typeof(GenericRepository<>));
builder.Services.AddScoped<IUnitOfWork, UnitOfWork>();
builder.Services.AddScoped(typeof(IBaseService<>), typeof(BaseService<>));

builder.Services.AddScoped<IUserMasterService, UserMasterService>();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Home/Error");
    // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthorization();

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");

app.Run();

Integration in Application

public class ProductController : Controller
{
    private readonly IUnitOfWork _unitOfWork;

    public ProductController(IUnitOfWork unitOfWork)
    {
        _unitOfWork = unitOfWork;
    }

    public async Task<IActionResult> Index()
    {
        var products = await _unitOfWork.Repository<Product>().GetAll();
        return View(products);
    }

    [HttpPost]
    public async Task<IActionResult> AddProduct(Product product)
    {
        await _unitOfWork.Repository<Product>().Insert(product);
        await _unitOfWork.SaveChangesAsync();
        return RedirectToAction("Index");
    }
}

Summary of Flow
Services like UnitOfWork, BaseService, and repositories are registered in the DI container.
Controllers or services request these dependencies through constructor injection.
The UnitOfWork is used to coordinate repository operations and manage transactions.
The application pipeline ensures a structured flow for requests, middleware, and responses.

Conclusion

Implementing the Unit of Work and Repository Pattern in an ASP.NET Core MVC application provides a modular, maintainable, and testable architecture. Here's why this approach is effective:
Centralized Data Access: The UnitOfWork ensures a single entry point for managing multiple repositories, making it easier to coordinate operations across multiple data entities.
Separation of Concerns: By abstracting data access logic into repositories and services, this design keeps your controllers focused on application flow and user interactions.
Consistency and Reusability:
The generic repository pattern eliminates redundant code by providing reusable CRUD operations.
Soft delete mechanisms (as seen in GenericRepository) ensure data consistency while preserving historical records.
Transaction Management: The UnitOfWork ensures that database changes across repositories are saved or rolled back as a single unit, enhancing data integrity.
Scalability: As the application grows, new entities and business logic can be easily added without disrupting the existing structure.
Ease of Testing: Dependency injection of repositories and UnitOfWork allows for mocking during unit tests, ensuring testable and reliable code.
By adopting this structure, your application gains a robust foundation that streamlines development, reduces redundancy, and improves code readability. This design pattern is ideal for scalable applications with complex business logic and multiple data entities.

Connect with me:@ LinkedIn

Angular 17+ Fundamentals : Everything you need to know in one place

Gaurav — Sun, 06 Oct 2024 12:09:54 +0000

If you're here, you're probably already interested in learning Angular and want to dive right into the fundamentals. There's no need to convince you why Angular is a powerful framework—you're likely aware of its popularity for building scalable, single-page applications. This guide is all about getting hands-on with Angular, so we’ll skip the sales pitch and jump straight into the essentials.

From setting up routing to handling complex data flows with signals, computed values, and deferrable views, this post will guide you through the key concepts you'll need to build dynamic, efficient Angular applications. Whether you're just getting started or need a quick refresher, I’ve got you covered with practical examples and explanations for every topic.

Let’s dive in!

Routing
Standalone Components
Forms
Property Binding
Event Handling
Conditional Rendering
For Loops in Angular
Passing Data Between Components
Reactive Primitives: Signals, Computed, and Effects
Deferrable Views

1. Routing

Routing allows you to navigate between different views in an Angular app. Here’s how routing is set up in Angular 17:

import { Routes } from '@angular/router';
import { BasicsComponent } from './basics/basics.component';
import { HomeComponent } from './home/home.component';
import { UserCardViewComponent } from './user-card-view/user-card-view.component';
import { OutputComponentComponent } from './output-component/output-component.component';

export const routes: Routes = [
    {
        path: 'basics',
        component: BasicsComponent
    },
    {
        path: '',
        component: HomeComponent
    },
    {
        // Passing data in the component from the URL
        path: 'user-card-view/:username',
        component: UserCardViewComponent
    },
    {
        path: 'output-view',
        component: OutputComponentComponent
    }
];

Description:

Dynamic Routes: In the user-card-view/:username route, :username is a dynamic parameter passed from the URL to the component.
Empty Path (path: ''): Navigating to the root of the application will load HomeComponent.

2. Standalone Components

Angular 17 introduced standalone components, making them more modular and independent. You can import other modules or components directly into a standalone component.

import { Component } from '@angular/core';
import { UserCardViewComponent } from '../user-card-view/user-card-view.component';
import { Router, RouterLink } from '@angular/router';
import { FormsModule, ReactiveFormsModule } from '@angular/forms';

@Component({
  selector: 'app-basics',
  standalone: true,
  imports: [UserCardViewComponent, RouterLink, FormsModule, ReactiveFormsModule],
  templateUrl: './basics.component.html',
  styleUrls: ['./basics.component.css']
})
export class BasicsComponent {
  // Component logic goes here
}

Description:

Standalone components reduce the dependency on Angular modules and allow for more modular development. You can directly import other components, directives, and services into them.

3. Forms

Template-Driven Forms
Template-driven forms are quick to set up but are best for simpler use cases:

<form name="loginForm">
    <label for="username">Username:</label>
    <input type="text" name="username" [(ngModel)]="username">

    <label for="password">Password:</label>
    <input type="password" name="password" [(ngModel)]="password">
</form>

<p>Username: {{ username }}</p>
<p>Password: {{ password }}</p>

Reactive Forms
Reactive forms are more powerful and scalable, especially for larger applications:

loginForm = new FormGroup({
    username: new FormControl(''),
    password: new FormControl('')
});

handleSubmit() {
    console.log(this.loginForm.value);
}

<form [formGroup]="loginForm" (ngSubmit)="handleSubmit()">
    <label for="username">Username:</label>
    <input formControlName="username">

    <label for="password">Password:</label>
    <input formControlName="password">

    <button type="submit">Submit</button>
</form>

Description:

Template-driven forms are quick to implement but require more effort when adding validation.
Reactive forms are highly configurable, providing better control over form state and validation.

4. Property Binding

Property binding dynamically sets properties in the DOM. This is done using square brackets [ ].

<button [disabled]="isDisabled">Submit</button>

In the component:

isDisabled = true;

Description:

Here, the button is disabled based on the value of isDisabled. Property binding updates the DOM property dynamically as the component's property changes.

5. Event Handling

Event binding allows you to respond to user interactions.

<button (click)="handleClick()">Submit</button>

In the component:

handleClick() {
  console.log('Button clicked!');
}

Description:

The event handler handleClick() is invoked whenever the button is clicked.

6. Conditional Rendering

If-Else Statements
You can control the visibility of elements using *ngIf.

@if(card.type === 'gold') {
    <span>Gold</span>
} @else if(card.type === 'silver') {
    <span>Silver</span>
} @else if(card.type === 'platinum') {
    <span>Platinum</span>
}

Switch-Case
For complex conditions, you can use @switch to improve readability.

@switch(card.type) {
    @case('gold') {
        <span>Gold</span>
    }
    @case('silver') {
        <span>Silver</span>
    }
    @case('platinum') {
        <span>Platinum</span>
    }
    @default {
        <span>Unknown Type</span>
    }
}

Description:

If-Else is used for simple conditionals.
Switch-Case is preferred when you need to handle multiple conditions, especially for readability and scalability.

7. For Loops in Angular

The @for directive lets you iterate over an array.

@for(item of cardList; track item) {
    <div class="card">
        <h5>{{item.name}}</h5>
        <p>{{item.number}}</p>
        <span>{{item.type}}</span>
    </div>
}

Description:

trackBy improves performance by uniquely identifying each item, ensuring the DOM efficiently handles large lists.

8. Passing Data Between Components

You can pass data between parent and child components using @Input() and @Output()
Sending Data to Child Component

<app-user-card-view [userCardData]="card"></app-user-card-view>

In UserCardViewComponent:

@Input() userCardData: CardModel;

Sending Data Back to Parent

@Output() selectedCard = new EventEmitter<any>();
sendDataToAnotherComponent() {
  this.selectedCard.emit(this.cardList);
}

Description:

@Input() allows a parent component to pass data to its child.
@Output() uses EventEmitter to send data from the child back to the parent component.

9. Reactive Primitives: Signals, Computed, and Effects

Angular 17 introduced Signals and Computed values for reactive programming.

Signals
Signals are reactive variables that automatically notify Angular when they change.

firstName = signal("Gaurav");

Computed Values
Computed values derive from other reactive values (signals).

fullName = computed(() =>${this.firstName()} ${this.lastName()});

Effects
Effects allow you to react to changes in signals or perform side effects.

effect(() => console.log(Full Name: ${this.fullName()}));

Description:

Signals provide a reactive data model, reducing the need for manual change detection.
Computed Values derive new values from existing signals.
Effects are used to perform actions when signals change.

10. Deferrable Views

Deferrable views allow for lazy-loading parts of the UI, based on certain conditions or user interactions.

Basic Example

<button #trigger>Load More</button>

@defer (on interaction(trigger)) {
    <p>Content loaded.</p>
} @loading {
    <p>Loading...</p>
} @error {
    <p>Error loading content.</p>
}

Advanced Example: Conditional Lazy Loading
You can defer loading content based on specific conditions:

<button (click)="counter = counter - 1">Make it Zero: {{counter}}</button>

@defer (when counter == 0) {
    <p>Content loaded when counter hits 0!</p>
} @placeholder {
    <p>Waiting for counter to hit 0...</p>
}

Description:

Deferrable Views improve performance by delaying the loading of heavy components until necessary.
The @loading, @error, and @placeholder directives provide a better user experience by giving feedback during the loading process.

Conclusion
This guide walks you through key Angular concepts like routing, standalone components, forms, and reactive primitives. With Angular 17’s new features like signals and deferrable views, you can create more efficient and reactive web applications.

Connect with me:@ LinkedIn

How to Make API Calls in Android Using Kotlin

Gaurav — Sat, 28 Sep 2024 01:51:49 +0000

In modern mobile app development, integrating with RESTful APIs is a common task. Often, these APIs require different types of HTTP methods, such as GET, POST, PUT, and DELETE, for different operations. In this blog post, we will walk through how to create a generic utility in Kotlin that allows you to call any of these methods seamlessly.

Why You Need a Generic API Call Utility

Rather than creating different functions for each HTTP method, it's more efficient to have a single method that can handle all types of requests. This helps in writing clean and maintainable code.

Step-by-Step Guide to Create a Generic API Utility

1. Setting Up the API Utility Class
Let’s start by creating an API utility class that handles all types of HTTP methods (GET, POST, PUT, DELETE). We'll use HttpURLConnection for this purpose, as it's a part of the Java standard library and works well for simple HTTP requests.

Here's the code for the utility:

class API {

    companion object {
        // Function to handle all HTTP methods
        fun callApi(apiUrl: String, token: String, httpMethod: String, requestModel: Any? = null): String {
            val response = StringBuilder()

            try {
                val url = URL(apiUrl)
                val connection = url.openConnection() as HttpURLConnection
                connection.requestMethod = httpMethod // Set the HTTP method (GET, POST, PUT, DELETE)

                // Set request headers for JSON format and authorization
                connection.setRequestProperty("Content-Type", "application/json")
                connection.setRequestProperty("Accept", "application/json")
                connection.setRequestProperty("Authorization", "Bearer $token")

                // Send request body for POST/PUT methods
                if (httpMethod == "POST" || httpMethod == "PUT") {
                    connection.doOutput = true
                    requestModel?.let {
                        val jsonInput = Gson().toJson(it)
                        OutputStreamWriter(connection.outputStream).use { os ->
                            os.write(jsonInput)
                            os.flush()
                        }
                    }
                }

                // Handle the response
                val responseCode = connection.responseCode
                if (responseCode == HttpURLConnection.HTTP_OK || responseCode == HttpURLConnection.HTTP_CREATED) {
                    BufferedReader(InputStreamReader(connection.inputStream, "utf-8")).use { br ->
                        var responseLine: String?
                        while (br.readLine().also { responseLine = it } != null) {
                            response.append(responseLine?.trim())
                        }
                    }
                } else {
                    // Handle error response
                    BufferedReader(InputStreamReader(connection.errorStream, "utf-8")).use { br ->
                        var responseLine: String?
                        while (br.readLine().also { responseLine = it } != null) {
                            response.append(responseLine?.trim())
                        }
                    }
                    println("Error Response Code: $responseCode, Message: ${connection.responseMessage}")
                }
            } catch (e: Exception) {
                e.printStackTrace()
                return e.message.toString()
            }

            return response.toString()
        }
    }
}

2. How It Works

HTTP Method: The function accepts an HTTP method (POST, GET, PUT, DELETE) and sets it dynamically using the requestMethod property.
Authorization: The Authorization header is set using a Bearer token.
Request Body: For POST and PUT methods, the request body is serialized to JSON using Gson and sent along with the request.
Response Handling: If the response code is 200 OK or 201 Created, the response body is read and returned. Otherwise, the error message is captured.

3. How to Call the Utility

You can use this utility in your Android application for any type of API call.

Example 1: POST Request

val apiUrl = "https://api.example.com/v1/resource"
val token = "your_token_here"

val requestBody = mapOf(
    "field1" to "value1",
    "field2" to "value2"
)

val response = API.callApi(apiUrl, token, "POST", requestBody)
println(response)

Example 2: GET Request

val apiUrl = "https://api.example.com/v1/resource/1"
val token = "your_token_here"

// No request body for GET
val response = API.callApi(apiUrl, token, "GET")
println(response)

Example 3: PUT Request

val apiUrl = "https://api.example.com/v1/resource/1"
val token = "your_token_here"

val requestBody = mapOf(
    "field1" to "new_value1",
    "field2" to "new_value2"
)

val response = API.callApi(apiUrl, token, "PUT", requestBody)
println(response)

Example 4: DELETE Request

val apiUrl = "https://api.example.com/v1/resource/{id}"
val token = "your_token_here"

// No request body for DELETE
val response = API.callApi(apiUrl, token, "DELETE")
println(response)

4. Adding Network Permissions
Don't forget to add the necessary permissions for network access in your AndroidManifest.xml file:

<uses-permission android:name="android.permission.INTERNET" />

Conclusion

By creating a generic API utility, you can easily handle multiple types of HTTP requests (GET, POST, PUT, DELETE) in your Android applications. This approach keeps your code clean, reusable, and easy to maintain, ensuring efficient communication with external APIs.

With this setup, you can quickly integrate with RESTful APIs in any Android project, saving time and reducing complexity.

That's all for today.

And also, share your favourite web dev resources to help the beginners here!

Connect with me:@ LinkedIn

Family Tree View in .NET MVC

Gaurav — Mon, 26 Aug 2024 15:34:01 +0000

A couple of days ago, a candidate came in for an interview at the company where I work. He was given a task to create a dynamic family tree chart in .NET MVC, where each parent node would have two child nodes. The challenge was that when logging in with a child node, that node should move to the top of the tree as the new parent.

Watching him attempt the task reminded me of my own interview here, where I was given the same assignment. I remember how challenging it was to not only understand the logic but also to implement it visually in a tree-like structure. Unfortunately, the candidate struggled with creating the view, even though he had a good grasp of the underlying logic.

I realized that this is a common challenge, so I decided to write a blog post to help others who might encounter this task in the future. Today, I’m going to guide you on how to create a family tree view in .NET MVC.

Project Structure :

Here, we're going to use Html.Partial to render our nodes and a for loop to iterate multiple times. By default, we should have a user called "admin" (in my case, but you can create a different user if you prefer).

First, let's connect the .NET project with the database. For that, use the following model. We’re going to use username as the main node, with leftmember and rightmember as their children. This structure will continue recursively, with each node having two child nodes. If a node has not yet been created, a button will be available to add it.

Model

namespace TASK_1._1.Models
{
    public class UserModel
    {
        [Key]
        public int userId { get; set; }
        [Required]
        public string firstName { get; set; }
        [Required]
        public string lastName { get; set; }
        [Required]
        public string userName { get; set; }
        [Required]
        public string password { get; set; }
        public string leftMember { get; set; } = "";
        public string rightMember { get; set; } = "";
    }
}

<div class="align-content-center">
    <br /><br />
    <form action="Auth" method="post">

        <div class="container">
            <label for="uname"><b>Username</b></label>
            <input type="text" placeholder="Enter Username" name="username" asp-route-username="username" required> <br /><br />

            <label for="psw"><b>Password</b></label>
            <input type="password" placeholder="Enter Password" name="password" asp-route-password="password" required><br /><br />

            <button type="submit" asp-action="Auth">Login</button>
            <br /><br />
        </div>


    </form>

</div>

Index Page

@inject TASK_1._1.Context.ApplicationDbContext context
@model List<UserModel> 
@{
    ViewData["Title"] = "Home Page"; 
}

<div class="text-center">
    @if (Model != null && Model.Count() > 0)
    {  
        <table border="1" class="text-center">  
            @foreach (var user in Model)
            { 
                @Html.Partial("_UserNodeView", user)
                break;
            }
        </table> 
    }
</div>

RegisterLeftMember

@model UserModel
@*
    For more information on enabling MVC for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860
*@
@{
}
<div class="text-center">

    <form action="AddMemberLeft" method="post">

        <div class="container">

            <label for="uname"><b>First Name</b></label>
            <input type="text" placeholder="Enter First Name" asp-for="firstName" required> <br /><br />

            <label for="uname"><b>Last Name</b></label>
            <input type="text" placeholder="Enter Last Name" asp-for="lastName" required> <br /><br />

            <label for="uname"><b>Username</b></label>
            <input type="text" placeholder="Enter Username" asp-for="userName" required> <br /><br />

            <label for="psw"><b>Password</b></label>
            <input type="password" placeholder="Enter Password" asp-for="password" required><br /><br />

            <button type="submit" asp-action="AddMemberLeft">Create</button>
            <br /><br />
        </div>

    </form>

</div>

RegisterRightMember

@model UserModel
@*
    For more information on enabling MVC for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860
*@
@{
}
<div class="text-center">

    <form action="AddMemberRight" method="post">

        <div class="container">

            <label for="uname"><b>First Name</b></label>
            <input type="text" placeholder="Enter First Name" asp-for="firstName" required> <br /><br />

            <label for="uname"><b>Last Name</b></label>
            <input type="text" placeholder="Enter Last Name" asp-for="lastName" required> <br /><br />

            <label for="uname"><b>Username</b></label>
            <input type="text" placeholder="Enter Username" asp-for="userName" required> <br /><br />

            <label for="psw"><b>Password</b></label>
            <input type="password" placeholder="Enter Password" asp-for="password" required><br /><br />

            <button type="submit" asp-action="AddMemberRight">Create</button>
            <br /><br />
        </div>

    </form>

</div>

_Layout.cshtml

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>@ViewData["Title"] - TASK_1._1</title>
    <link rel="stylesheet" href="~/lib/bootstrap/dist/css/bootstrap.min.css" />
    <link rel="stylesheet" href="~/css/site.css" asp-append-version="true" />
    <link rel="stylesheet" href="~/TASK_1._1.styles.css" asp-append-version="true" />
</head>
<body>
    <header>

    </header>
    <div class="container">
        <main role="main" class="pb-3">
            @RenderBody()
        </main>
    </div>

    <script src="~/lib/jquery/dist/jquery.min.js"></script>
    <script src="~/lib/bootstrap/dist/js/bootstrap.bundle.min.js"></script>
    <script src="~/js/site.js" asp-append-version="true"></script>
    @await RenderSectionAsync("Scripts", required: false)
</body>
</html>

_UserNodeView.cshtml

@inject TASK_1._1.Context.ApplicationDbContext context
@model UserModel
@*
    For more information on enabling MVC for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860
*@
@{
}

<table border="1" class="text-center">
    <a> @Model.userName </a>
        <tr>
            <td>
            @if (Model.leftMember.Equals(""))
                {
                    <div>
                        <form asp-controller="Home" asp-action="AddMyLeftMember" method="post">
                        <button class="btn btn-primary" type="submit" asp-action="AddMyLeftMember" asp-route-userId="@Model.userId"> Left </button>
                        </form>
                    </div>
                }
                else
                {
                    var u = context.User.Where(n => n.userName == Model.leftMember).FirstOrDefault();
                    @Html.Partial("_UserNodeView", u)
                }
            </td>

            <td>
            @if (Model.rightMember.Equals(""))
                {
                    <div>
                        <form asp-controller="Home" asp-action="AddMyRightMember" method="post">
                        <button class="btn btn-primary" type="submit" asp-action="AddMyRightMember" asp-route-userId="@Model.userId"> Right </button>
                        </form>
                    </div>
                }
                else
                {
                    var u = context.User.Where(n => n.userName == Model.rightMember).FirstOrDefault();
                    @Html.Partial("_UserNodeView", u)
                }
            </td>
        </tr>

</table>

Controller

namespace TASK_1._1.Controllers
{
    public class HomeController : Controller
    {
        private readonly ILogger<HomeController> _logger;
        private readonly ApplicationDbContext context;

        public HomeController(ILogger<HomeController> logger, ApplicationDbContext context)
        {
            _logger = logger;
            this.context = context;
        }

        public IActionResult Index()
        { 
            List<UserModel> users = context.User.ToList();

            string name = User.Identity.Name;

            if(name == null || name.Equals(""))
            {
                name = "admin";
            }

            List<UserModel> newUserList = users.Where(user => String.Compare(user.userName, User.Identity.Name) >= 0).ToList();
            return View(newUserList);

        }

        public async Task<IActionResult> addMyLeftMember(int userId)
        { 
            TempData["LeftMemberUserId"] = userId;
            return RedirectToAction("RegisterLeftMember");
        }

        public async Task<IActionResult> addMyRightMember(int userId)
        {
            TempData["RightMemberUserId"] = userId;
            return RedirectToAction("RegisterRightMember");
        }

        public async Task<IActionResult> AddMemberLeft(UserModel userModel)
        {

            UserModel usr = context.User.Where(n => n.userName == userModel.userName).FirstOrDefault();

            if(usr != null)
            {
                return Content("user already exist");
            }

            int userID = int.Parse(TempData["LeftMemberUserId"].ToString());
            var findingDaddy = context.User.Where(n => n.userId == userID).FirstOrDefault();


            findingDaddy.leftMember = userModel.userName;

            context.User.Add(userModel);
            await context.SaveChangesAsync();

            return RedirectToAction("Index");
        }

        public async Task<IActionResult> AddMemberRight(UserModel userModel)
        {

            UserModel usr = context.User.Where(n => n.userName == userModel.userName).FirstOrDefault();

            if (usr != null)
            {
                return Content("user already exist");
            }

            int userID = int.Parse(TempData["RightMemberUserId"].ToString());
            var findingDaddy = context.User.Where(n => n.userId == userID).FirstOrDefault();

            findingDaddy.rightMember = userModel.userName;

            context.User.Add(userModel);
            await context.SaveChangesAsync();

            return RedirectToAction("Index");
        }

        public IActionResult RegisterLeftMember()
        {
            return View();
        }

        public IActionResult RegisterRightMember()
        {
            return View();
        }

        public IActionResult Login()
        {
            return View();
        }

        public IActionResult Privacy()
        {
            return View();
        }

        [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
        public IActionResult Error()
        {
            return View(new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier });
        }

        [HttpPost]
        public async Task<IActionResult> Auth(string username, string password)
        {

            var findingFeni = context.User.Where(n => n.userName == username && n.password == password).FirstOrDefault();

            if(findingFeni == null)
            { 
                return Content("user or password is incorrect");
            }

            var claims = new List<Claim>
            {
                new Claim(ClaimTypes.Name, username)
            };

            var claimsIdentity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);

            var authProperties = new AuthenticationProperties
            {

            };

            await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme,
                new ClaimsPrincipal(claimsIdentity), authProperties);

            return RedirectToAction("Index");

        }

    }
}

Default User

User with Child Nodes

Final View

That's all for today.

And also, share your favourite web dev resources to help the beginners here!

Connect with me:@ LinkedIn and checkout my Portfolio.

Serilog Integration in .NET

Gaurav — Mon, 05 Aug 2024 14:01:38 +0000

Serilog is a newer logging framework for . NET. It was built with structured logging in mind. It makes it easy to record custom object properties and even output your logs to JSON.

How to install Serilog via Nuget and get started

Starting with Serilog is as easy as installing a Serilog Nuget package. You will also want to pick some logging sinks to direct where your log messages should go, including the console and a text file.

Install-Package Serilog
dotnet add package Serillog.ASPNetCore

If you want to store the logs in file

Install-Package Serilog.Sinks.File
dotnet add package Serillog.Sinks.File

Create a Service Class for Configuring the Serillog

public static class AppExtension
{
    public static void SerilLogConfiruation( this IHostBuilder host )
    {
        host.UseSerillog((context, loggerConfig)=> {
            loggerConfig.WriteTo.Console();

                        //store logs in json format
            loggerConfig.WriteTo.File(new JsonFormatter(),"logs/applogs.txt");

                        //store logs in text format
            //loggerConfig.WriteTo.File("logs/applogs.txt");

        }),
    }
}

Add Serillog in Program.cs

builder.Host.SerillogConfiguration();

[ApiController]
[Route("[controller]")]
public class DemoController : ControllerBase 
{
    private readonly ILogger<DemoController> _ilogger;

    public DemoController(ILogger<DemoController> logger)   
    {
        _ilogger = logger;
    }

    [Https]
    public IEnumerable<string> Get() 
    {
        _logger.LogInformation("Demo Controller Get is Called");
        return null;
    }
}

Reset Firebase User Password in C# Using Firebase SDK

Gaurav — Thu, 01 Aug 2024 05:50:58 +0000

In this guide, we'll walk through the process of resetting a user's password in a C# application using the Firebase SDK. This functionality is essential for providing a smooth user experience, allowing users to recover their accounts in case they forget their passwords

Firebase Authentication provides an easy way to integrate user authentication into apps. It supports various sign-in methods like email/password, phone number, and social media accounts. Users can manage their passwords and receive email verification. The service ensures secure authentication and integrates well with other Firebase tools

Set Up Firebase SDK:
Make sure you have the Firebase SDK installed and configured in your C# project. You can add it via NuGet Package Manager.

Initialize Firebase:
Ensure that your Firebase application is initialized correctly with the required credentials. Navigate to Below Service Accounts as Method in Below Image and Click on Generate New Private Key to get it will give you a .json file which contains the Firebase credentials.

namespace demo.Services.Implementation
{
    public class Service : IService
    {  
        private readonly FirebaseAuth _firebaseAuth;

        public Service(IHTTPService httpService)
        { 
            _httpService = httpService;

            var FilePath = Path.Combine(Directory.GetCurrentDirectory(), "Firebase/your-json-file-name.json");


         // Check if the default FirebaseApp instance already exists
         if (FirebaseApp.DefaultInstance == null)
         {
             FirebaseApp.Create(new AppOptions()
             {
                 Credential = GoogleCredential.FromFile(FilePath)
             });
         }
            _firebaseAuth = FirebaseAuth.DefaultInstance;
        }

        public async Task resetPassword(string Email, string newPassword)
        {

            var uid = await getUID(Email);

            var userRecordArgs = new UserRecordArgs()
            {
                Uid = uid,
                Password = newPassword,
            };

            await _firebaseAuth.UpdateUserAsync(userRecordArgs);
        }

        public async Task<string> getUID(string email)
        {
            var userRecord = await _firebaseAuth.GetUserByEmailAsync(email);
            return userRecord.Uid;
        }

    }
}

Conclusion:

Integrating Firebase Authentication into your C# application to handle password resets is a straightforward process that significantly enhances the user experience. By following the steps outlined in this guide, you can provide a secure and efficient way for users to recover their accounts. The Firebase SDK offers robust support for various authentication methods, ensuring seamless integration with your application. Remember to keep your Firebase credentials secure and regularly update your application's dependencies to maintain security and functionality. With these practices in place, you can confidently manage user authentication and password recovery in your C# applications.

Forem: Gaurav

🚀 Getting Started with RabbitMQ Pub/Sub using MassTransit in .NET

Custom Middleware Extensions in .NET Core Web API

What is Middleware?

Step 2: Building the Middleware Classes

Benefits of Middleware Extensions

Conclusion

Dependency Injection in ASP.NET Core with Extension Classes: A Comprehensive Guide

What is Dependency Injection?

Benefits of Using Extension Classes for DI

Example: Dependency Injection Using an Extension Class

Key Points in the Example

Benefits of the Approach

Conclusion

Securing Your .NET APIs with JWT Authentication

1. Prerequisites

2. Generate JWT Tokens

Key Points:

3. Configure JWT Authentication Middleware

Key Points:

4. Secure API Endpoints

Key Points:

5. Enable Swagger to Accept JWT Tokens

Key Points:

6. Test the Implementation

7. Conclusion

.NET Core MVC Project Structure : Implementing a Generic Service and Repository Pattern

1. BaseService

2. GenericRepository

3. UnitOfWork

Angular 17+ Fundamentals : Everything you need to know in one place

Table of Contents

1. Routing

2. Standalone Components

3. Forms

4. Property Binding

5. Event Handling

6. Conditional Rendering

7. For Loops in Angular

8. Passing Data Between Components

9. Reactive Primitives: Signals, Computed, and Effects

10. Deferrable Views

How to Make API Calls in Android Using Kotlin

Why You Need a Generic API Call Utility

Step-by-Step Guide to Create a Generic API Utility

2. How It Works

3. How to Call the Utility

Conclusion

Family Tree View in .NET MVC

Serilog Integration in .NET

Reset Firebase User Password in C# Using Firebase SDK