When I put authorize on the controller I have problems

Question

Guys I'm really going crazy. If I insert the Authorize annotation with police or role on the controller, even though I log in it always gives me a 404 error. If I don't insert role or police it acts as if Authorize was there. Help me!! I insert controller and program.cs

controller

using AutoMapper;
using IlGiroGiusto.BLL.interfaces;
using IlGiroGiusto.BLL.models;
using IlGiroGiusto.BLL.Services;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace IlGiroGiusto.PL.WebAPI.Controllers
{
        [Route("api/[controller]")]
        [ApiController]
        [Authorize(Policy="Admin")]

    public class PaymentController : ControllerBase
        {
            private readonly IPaymentService _paymentService;
            private readonly IMapper _mapper;

            public PaymentController(IPaymentService paymentService, IMapper mapper)
            {
                _paymentService = paymentService;
                _mapper = mapper;
            }

        [HttpDelete]
            [Route("DeletePayment")]
            public async Task<IActionResult> DeletePayment(int paymentId)
            {
                await _paymentService.DeletePaymentAsync(paymentId);
                return Ok();
            }

            [HttpGet("GetAllPayments")]
            public async Task<IActionResult> GetAllPayments()
            {
                return Ok(await _paymentService.GetAllPaymentsAsync());
            }

            [HttpGet("GetPaymentById")]
            public async Task<IActionResult> GetPublisherByName(int paymentId)
            {
                return Ok(await _paymentService.GetPaymentByIdAsync(paymentId));
            }

        [HttpGet("GetPaymentsByDate")]
        public async Task<IActionResult> GetPaymentsByDate(DateTime date)
        {
            return Ok(await _paymentService.GetPaymentsByDateAsync(date));
        }

        
        [HttpPost("SetPayment")]
        public async Task<IActionResult> SetPayment(int paymentId)
        {
            await _paymentService.SetPayment(paymentId);
            return Ok();
        }
    }
}

program

using IlGiroGiusto.BLL.interfaces;
using IlGiroGiusto.BLL.Services;
using IlGiroGiusto.PL.WebAPI.Configuration;
using IlGIroGiusto.DAL;
using IlGIroGiusto.DAL.Entities;
using IlGIroGiusto.DAL.Interfaces;
using IlGIroGiusto.DAL.Repositories;
using Microsoft.AspNetCore.Authentication.Cookies;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using Microsoft.OpenApi.Models;
using MovieStorage.DAL.MSSQL.Repositories;
using Swashbuckle;



var builder = WebApplication.CreateBuilder(args);

var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");


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


builder.Services.AddAuthorization(options =>
    {

        options.AddPolicy("Admin",
                policy =>
                {
                    policy.RequireAuthenticatedUser();
                    policy.RequireRole("Admin");
                });
       
    });

builder.Services.AddIdentityCore<User>(options =>

    {
        options.Password.RequiredLength = 6;
        options.Password.RequireDigit = false;
        options.Password.RequireLowercase = false;
        options.Password.RequireUppercase = false;
        options.Password.RequireNonAlphanumeric = false;
    });





builder.Services.AddIdentity<User, IdentityRole>()
.AddEntityFrameworkStores<IlGiroGiustoDbContext>()
.AddSignInManager<SignInManager<User>>()
.AddUserManager<UserManager<User>>();



builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen(c =>
{
        c.SwaggerDoc("v1", new OpenApiInfo { Title = "IlGiroGiusto", Version = "v1" });
        //c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
        //{
        //        In = ParameterLocation.Header,
        //        Description = "Enter 'Bearer {token}'",
        //        Name = "Authorization",
        //        Type = SecuritySchemeType.ApiKey
        //});
        //    c.AddSecurityRequirement(new OpenApiSecurityRequirement
        //    {
        //        {
        //            new OpenApiSecurityScheme
        //            {
        //                Reference = new OpenApiReference
        //                {
        //                    Type = ReferenceType.SecurityScheme,
        //                    Id = "Bearer"
        //                }
        //            },
        //            new string[] { }
        //        }
        //});
});

builder.Services.AddAuthentication(options =>
{
    options.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme;
    options.DefaultSignInScheme = CookieAuthenticationDefaults.AuthenticationScheme;
    options.DefaultAuthenticateScheme = CookieAuthenticationDefaults.AuthenticationScheme;
    options.DefaultChallengeScheme = CookieAuthenticationDefaults.AuthenticationScheme;
})
.AddCookie(options =>
{
    options.LoginPath = "/Account/Login";
    options.AccessDeniedPath = "/Account/AccessDenied";
    options.ExpireTimeSpan = TimeSpan.FromMinutes(20);
    options.SlidingExpiration = true;

});

builder.Services.AddScoped(typeof(IGenericRepository<>), typeof(GenericRepository<>));

builder.Services.AddScoped<IBookRepository, BookRepository>();
builder.Services.AddScoped<IBookService, BookService>();


builder.Services.AddScoped<IAuthorRepository, AuthorRepository>();
builder.Services.AddScoped<IAuthorService, AuthorService>();

builder.Services.AddScoped<ICartItemRepository, CartItemRepository>();
builder.Services.AddScoped<ICartItemService, CartItemService>();


builder.Services.AddScoped<ICategoryRepository, CategoryRepository>();
builder.Services.AddScoped<ICategoryService, CategoryService>();

builder.Services.AddScoped<IPublisherRepository, PublisherRepository>();
builder.Services.AddScoped<IPublisherService, PublisherService>();

builder.Services.AddScoped<ICartItemRepository, CartItemRepository>();

builder.Services.AddScoped<IBookStockRepository, BookStockRepository>();
builder.Services.AddScoped<IBookStockService, BookStockService>();


builder.Services.AddScoped<IUserRepository, UserRepository>();
builder.Services.AddScoped<IUserService, UserService>();

builder.Services.AddScoped<IPaymentRepository, PaymentRepository>();
builder.Services.AddScoped<IPaymentService, PaymentService>();

builder.Services.AddScoped<IOrderRepository, OrderRepository>();
builder.Services.AddScoped<IOrderService, OrderService>();

builder.Services.AddScoped<IStockStatisticsService, StockStatisticsService>();



builder.Services.AddScoped<ICartRepository, CartRepository>();
builder.Services.AddScoped<ICartService, CartService>();


builder.Services.AddAutoMapper(typeof(MappingProfile));

var app = builder.Build();



    

//app.UseHttpsRedirection();

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

app.UseSwagger();
app.UseSwaggerUI(c =>
{
    c.SwaggerEndpoint("/swagger/v1/swagger.json", "IlGiroGiusto");
});
app.MapControllers();

app.Run();

I've tried a lot but it can't go

Answer 1

The solution is that it recall an external function rather than a Microsoft Identity function.