Program.cs

using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.AspNetCore.Diagnostics;
using Microsoft.EntityFrameworkCore;
using Microsoft.IdentityModel.Tokens;
using Microsoft.OpenApi.Models;
using MPS.API.DAL;
using MPS.API.Shared;
using Newtonsoft.Json;
using System.Text;
using System.Text.Json.Serialization;

namespace MPS.API
{
    public class Program
    {
        public static IConfiguration? Configuration;

        public static void Main(string[] args)
        {
            var builder = WebApplication.CreateBuilder(args);
            Configuration = builder.Configuration;

            var IssuerSigningKey = Configuration.GetValue<string>("IssuerSigningKey");
            if (IssuerSigningKey != null)
                builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
                    .AddJwtBearer(jwtBearerOptions =>
                    {
                        jwtBearerOptions.TokenValidationParameters = new TokenValidationParameters()
                        {
                            ValidateActor = true,
                            ValidateAudience = true,
                            ValidateLifetime = true,
                            ValidateIssuerSigningKey = true,
                            ValidIssuer = "Issuer",
                            ValidAudience = "Audience",
                            SaveSigninToken = true,
                            RequireExpirationTime = true,
                            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(IssuerSigningKey))
                        };
                    });

            builder.Services.AddAuthorization(options =>
            {
                options.AddPolicy("System", policy =>
                    policy.RequireClaim("UserType", UserType.SYS.ToString()));
                options.AddPolicy("Organization", policy =>
                    policy.RequireClaim("UserType", UserType.ORGANIZATION.ToString()));
                options.AddPolicy("Provider", policy =>
                    policy.RequireClaim("UserType", UserType.PROVIDER.ToString()));
            });

            builder.Services.AddMemoryCache();

            // Add services to the container.
            builder.Services.AddCors();
            builder.Services.AddControllers()
                            .AddJsonOptions(options =>
                            {
                                options.JsonSerializerOptions.ReferenceHandler = ReferenceHandler.Preserve;
                                options.JsonSerializerOptions.WriteIndented = true; // Optional: for better readability
                            });

            builder.Services.AddEndpointsApiExplorer();
            builder.Services.AddSwaggerGen(options =>
            {
                options.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme()
                {
                    Name = "Authorization",
                    In = ParameterLocation.Header,
                    Type = SecuritySchemeType.Http,
                    Scheme = "Bearer"
                });

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

            // Learn more about configuring OpenAPI at https://aka.ms/aspnet/openapi
            builder.Services.AddOpenApi();

            var ConnectionString = Configuration.GetValue<string>("ConnectionString");
            if (ConnectionString != null)
                builder.Services.AddDbContext<MpsContext>(options =>
                {
                    options.UseMySQL(ConnectionString);
                });

            var app = builder.Build();

            app.UseExceptionHandler(a => a.Run(async context =>
            {
                var exceptionHandlerPathFeature = context.Features.Get<IExceptionHandlerPathFeature>();
                var exception = exceptionHandlerPathFeature?.Error;

                var result = JsonConvert.SerializeObject(new
                {
                    IsSuccess = false,
                    ErrorCode = System.Net.HttpStatusCode.InternalServerError,
                    Message = exception?.Message,
                    InnerException = (exception?.InnerException != null) ? exception?.InnerException?.Message : null
                });
                context.Response.ContentType = "application/json";
                await context.Response.WriteAsync(result);
            }));

            // Configure the HTTP request pipeline.
            if (app.Environment.IsDevelopment())
            {
                app.MapOpenApi();
                app.UseSwagger();
                app.UseSwaggerUI(options =>
                {
                    options.SwaggerEndpoint("/swagger/v1/swagger.json", "v1");
                    options.RoutePrefix = string.Empty;
                });
                app.UseCors(builder => builder
                   .AllowAnyOrigin()
                   .AllowAnyMethod()
                   .AllowAnyHeader());
            }

            //app.UseHttpsRedirection();

            app.UseAuthorization();


            app.MapControllers();

            app.Run();
        }
    }
}