Program.cs

using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.EntityFrameworkCore;
using Microsoft.IdentityModel.Tokens;
using Microsoft.OpenApi.Models;
using System.Text;
using SPlaceBackend.Infrastructure;
using SPlaceBackend.Infrastructure.Repositories;
using SPlaceBackend.Application.Services;
using SPlaceBackend.Infrastructure.Hubs;
using SPlaceBackend.Application.Interfaces.Repositories;
using SPlaceBackend.Application.Interfaces.Authentication;
using SPlaceBackend.Infrastructure.Authentication;
using SPlaceBackend.Application.Interfaces.Services;
using SPlaceBackend.Application.ExceptionsHandler;
using SPlaceBackend.Application.Interfaces.Infrastructure;

namespace SPlaceBackend
{
    public class Program
    {
        public static void Main(string[] args)
        {
            var builder = WebApplication.CreateBuilder(args);

            builder.Services.AddEndpointsApiExplorer();

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

                var jwtSecurityScheme = new OpenApiSecurityScheme
                {
                    BearerFormat = "JWT",
                    Name = "Authorization",
                    In = ParameterLocation.Header,
                    Type = SecuritySchemeType.Http,
                    Scheme = JwtBearerDefaults.AuthenticationScheme,
                    Description = "Enter 'Bearer <your-token>'",
                    Reference = new OpenApiReference
                    {
                        Id = JwtBearerDefaults.AuthenticationScheme,
                        Type = ReferenceType.SecurityScheme,
                    }
                };

                options.AddSecurityDefinition("Bearer", jwtSecurityScheme);
                options.AddSecurityRequirement(new OpenApiSecurityRequirement
                {
                    { jwtSecurityScheme, Array.Empty<string>() }
                });
            });

            builder.Services.AddDbContext<SPlaceContext>(options =>
            {
                options.UseSqlServer(builder.Configuration.GetConnectionString("SqlServerConnStr"));
            });

            builder.Services.Configure<JwtOptions>(builder.Configuration.GetSection(nameof(JwtOptions)));

            builder.Services.AddScoped<IUsersRepository, UsersRepository>()
                            .AddScoped<IGroupsRepository, GroupsRepository>()
                            .AddScoped<IUserGroupsRepository, UserGroupsRepository>()
                            .AddScoped<IUserMessagesRepository, UserMessagesRepository>()
                            .AddScoped<IQuizzesRepository, QuizzesRepository>()
                            .AddScoped<IQuestionsRepository, QuestionsRepository>()
                            .AddScoped<IAnswersRepository, AnswersRepository>()
                            .AddScoped<IScoresRepository, ScoresRepository>();

            builder.Services.AddScoped<IPasswordHasher, PasswordHasher>()
                            .AddScoped<IJwtGenerator, JwtGenerator>()
                            .AddScoped<IUnitOfWork, UnitOfWork>();

            builder.Services.AddScoped<IUserService, UserService>()
                            .AddScoped<IGroupService, GroupService>()
                            .AddScoped<IMessageService, MessageService>()
                            .AddScoped<IQuizService, QuizService>();

            builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
                .AddJwtBearer(options =>
                {
                    options.TokenValidationParameters = new TokenValidationParameters
                    {
                        ValidateIssuer = false,
                        ValidateAudience = false,
                        ValidateIssuerSigningKey = true,
                        IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(builder.Configuration["JwtOptions:SecretKey"]!)),
                        ValidateLifetime = true,
                    };
                });

            builder.Services.AddCors(option =>
            {
                option.AddDefaultPolicy(builder =>
                {
                    builder
                    .WithOrigins("http://localhost:4200")
                    .AllowAnyMethod()
                    .AllowAnyHeader()
                    .AllowCredentials();

                    builder
                    .WithOrigins("https://splaceclient.azurewebsites.net")
                    .AllowAnyMethod()
                    .AllowAnyHeader()
                    .AllowCredentials();
                });
            });

            builder.Services.AddSignalR();
            builder.Services.AddSingleton<ApplicationHub>();

            builder.Services.AddControllers();

            builder.Services.AddProblemDetails()
                            .AddExceptionHandler<GlobalExceptionsHandler>();

            var app = builder.Build();

            if (builder.Environment.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
                app.UseSwagger();
                app.UseSwaggerUI(c => c.SwaggerEndpoint("/swagger/v1/swagger.json", "SPlaceBackend V1"));
            }

            app.UseHttpsRedirection();

            app.UseExceptionHandler();

            app.UseCors();

            app.UseRouting();

            app.UseAuthentication();

            app.UseAuthorization();

            app.MapHub<ApplicationHub>("/application");

            app.MapControllers();

            app.Run();
        }
    }
}