Jwt-Swagger.txt

using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;

using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http.HttpResults;
using Microsoft.IdentityModel.Tokens;
using Microsoft.OpenApi.Models;
using MinimalJwt.Models;
using MinimalJwt.Services;

var builder = WebApplication.CreateBuilder(args);

var _config = builder.Configuration;


builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(options =>
{
    options.TokenValidationParameters = new TokenValidationParameters()
    {
        ValidateActor = true,
        ValidateAudience = true,
        ValidateLifetime = true,
        ValidateIssuerSigningKey = true,
        ValidIssuer = _config["Jwt:Issuer"],
        ValidAudience = _config["Jwt:Audience"],
        IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config["Jwt:Key"]))

    };
});


builder.Services.AddAuthorization();




builder.Services.AddEndpointsApiExplorer();


//configuration for swagger token authentication
builder.Services.AddSwaggerGen(options =>
{
    options.AddSecurityDefinition("Bearer",new OpenApiSecurityScheme
    { Scheme = "Bearer",
    BearerFormat = "JWT",
    In = ParameterLocation.Header,
    Name = "Authorization",
    Description = "Bearer Authentication with Jwt Token",
    Type = SecuritySchemeType.Http
    }
        );

    options.AddSecurityRequirement(new OpenApiSecurityRequirement
    {
        {
            new OpenApiSecurityScheme
            {
                Reference = new OpenApiReference
                {
                    Id = "Bearer",
                    Type = ReferenceType.SecurityScheme
                }

            },
            new List<string>()
        }
    } );

});

builder.Services.AddSingleton<IMovieService, MovieService>();

builder.Services.AddSingleton<IUserService, UserService>();
var app = builder.Build();




if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

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

app.MapPost("/login", (UserLogin user, IUserService service) => Login(user, service));

IResult Login(UserLogin user, IUserService service)
{
   if(!string.IsNullOrEmpty(user.Username) && !string.IsNullOrEmpty(user.Password))
    {
        var loggedInUser = service.GetUser(user);
        if (loggedInUser is null) return Results.NotFound("User not found,register");

        var claims = new[]
        {
            new Claim(ClaimTypes.NameIdentifier,loggedInUser.Username),
            new Claim(ClaimTypes.Email,loggedInUser.Email),
            new Claim(ClaimTypes.GivenName,loggedInUser.Givenname),
            new Claim(ClaimTypes.Surname,loggedInUser.Surname),
            new Claim(ClaimTypes.Role,loggedInUser.Role),
        };

        var token = new JwtSecurityToken
        (
            issuer: _config["Jwt:Issuer"],
            audience: _config["Jwt:Audience"],
            claims: claims,
            expires: DateTime.UtcNow.AddDays(15),
            notBefore: DateTime.UtcNow
            ,
            signingCredentials: new SigningCredentials
            (new SymmetricSecurityKey
            (Encoding.UTF8.GetBytes(_config["Jwt:Key"])),
            SecurityAlgorithms.HmacSha256)
        );

        var tokenString = new JwtSecurityTokenHandler().WriteToken(token);

        return Results.Ok(tokenString);
    }
   return Results.NotFound();
}




app.MapPost("/create",
    [Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme,Roles = "Admin")]
    (Movie movie, IMovieService services) => Create(movie, services));

IResult Create(Movie movie, IMovieService services)
{
  var result=  services.Create(movie);
    return Results.Ok(result);

}

app.MapGet("/get",
    [Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme, Roles = "Admin,Standerd")] 
(int Id, IMovieService services) => Get(Id, services));

IResult Get(int id, IMovieService services)
{
   var movie= services.Get(id);
    if (movie is null) return Results.NotFound("Movie not found");
    return Results.Ok(movie);
}

app.MapGet("/list",(IMovieService services) => List(services));

IResult List(IMovieService services)
{
    var movies = services.List();
    return Results.Ok(movies);


}

app.MapPut("/update",
      [Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme, Roles = "Admin")]
(Movie newmovie, IMovieService services) => Update(newmovie, services));

IResult Update(Movie newmovie, IMovieService services)
{
    var updatedMovie=services.Update(newmovie);
    if (updatedMovie is null) return Results.NotFound("Movie not found");
    return Results.Ok(updatedMovie);
}

app.MapDelete("/delete", (int Id, IMovieService services) => Delete(Id, services));

IResult Delete(int id, IMovieService services)
{
    var result= services.Delete(id);
    if (!result) return Results.NotFound("Something went wrong");
    return Results.Ok(result);
}

app.Run();