Program.cs

using Microsoft.EntityFrameworkCore;
using AKhderApi.Context;
using AKhderApi.Repositories;
using AKhderApi.Helpers;
using Microsoft.AspNetCore.Identity;
using AKhderApi.Models;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.IdentityModel.Tokens;
using System.Text;
using AKhderApi.Services;
using Microsoft.AspNetCore.Authentication.Cookies;
using Microsoft.AspNetCore.Authentication.Google;
using FluentValidation;
using AKhderApi.Validators;
using Microsoft.OpenApi.Models;
using Stripe;
using SmartCartCarbonFootprintApi.Services;
using InvoiceService = SmartCartCarbonFootprintApi.Services.InvoiceService;
using SmartCartCarbonFootprintApi.Helpers;
using AKhderApi.Hubs;

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

            // Add services to the container.
            builder.Services.AddCors(options =>
            {
                options.AddPolicy("AllowAll",
                    builder =>
                    {
                        builder.AllowAnyOrigin()
                               .AllowAnyMethod()
                               .AllowAnyHeader();
                    });
            });


            // Add services to the container.

            builder.Services.Configure<JWT>(builder.Configuration.GetSection("JWT"));
            builder.Services.PostConfigure<JWT>(options =>
            {
                options.Key = Environment.GetEnvironmentVariable("JWT_KEY") ?? options.Key;
            });
            builder.Services.AddIdentity<User, IdentityRole>()
                .AddEntityFrameworkStores<AppDbContext>()
                .AddDefaultTokenProviders();

            builder.Services.AddScoped<IAuthService, AuthService>();
            builder.Services.AddScoped<AuthService>();
            builder.Services.AddScoped<IUserService, UserService>();
            builder.Services.AddScoped<IEmailService, EmailService>();
            builder.Services.AddDbContext<AppDbContext>(options =>
              options.UseLazyLoadingProxies().UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));
            builder.Services.AddAuthentication(options =>
            {
                options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
                options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
            }).AddJwtBearer(o =>
            {
                o.RequireHttpsMetadata = false;
                o.SaveToken = false;
                o.TokenValidationParameters = new TokenValidationParameters
                {
                    ValidateIssuerSigningKey = true,
                    ValidateIssuer = true,
                    ValidateAudience = true,
                    ValidateLifetime = true,
                    ValidIssuer = builder.Configuration["JWT:Issuer"],
                    ValidAudience = builder.Configuration["JWT:Audience"],
                    IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Environment.GetEnvironmentVariable("JWT_KEY") ?? builder.Configuration["JWT:Key"]!)),
                    NameClaimType = "uid",
                    ClockSkew = TimeSpan.Zero
                };
            })
            // Add Cookie authentication for external login (Google)
            .AddCookie(CookieAuthenticationDefaults.AuthenticationScheme, options =>
            {
                options.LoginPath = "/api/Auth/LoginGoogle"; // Set the login path for initiating Google login
                options.Events.OnRedirectToLogin = context =>
                {
                    // Return 401 instead of redirecting to the login page
                    context.Response.StatusCode = StatusCodes.Status401Unauthorized;
                    return Task.CompletedTask;
                };
                options.Events.OnRedirectToAccessDenied = context =>
                {
                    // Return 403 instead of redirecting
                    context.Response.StatusCode = StatusCodes.Status403Forbidden;
                    return Task.CompletedTask;
                };
            })
            .AddGoogle(GoogleDefaults.AuthenticationScheme, options =>
            {
                options.ClientId = Environment.GetEnvironmentVariable("GOOGLE_CLIENTID") ?? builder.Configuration["Authentication:Google:ClientId"]!;
                options.ClientSecret = Environment.GetEnvironmentVariable("GOOGLE_CLIENTSECRET") ?? builder.Configuration["Authentication:Google:ClientSecret"]!;

                options.Scope.Add("profile");
                options.SaveTokens = true;
                options.SignInScheme = CookieAuthenticationDefaults.AuthenticationScheme; // Use cookies for sign-in
            })
            .AddFacebook(facebookOptions =>
            {
                facebookOptions.AppId = Environment.GetEnvironmentVariable("FACE_APPID") ?? builder.Configuration["Authentication:Facebook:AppId"]!;
                facebookOptions.AppSecret = Environment.GetEnvironmentVariable("FACE_APPSECRET") ?? builder.Configuration["Authentication:Facebook:AppSecret"]!;
                facebookOptions.SaveTokens = true;
                facebookOptions.Scope.Add("public_profile");
                facebookOptions.SignInScheme = CookieAuthenticationDefaults.AuthenticationScheme;
            });

            builder.Services.AddControllers();
            builder.Services.AddScoped(typeof(IGenericRepository<>), typeof(GenericRepository<>));
            builder.Services.AddValidatorsFromAssemblyContaining<UserValidator>();
            builder.Services.AddScoped<IUnitOfWork, UnitOfWork>();
            builder.Services.AddAutoMapper(typeof(Program).Assembly);
            builder.Services.AddAutoMapper(typeof(MappingProfile).Assembly);
            builder.Services.AddMemoryCache();
            var emailSettings = new EmailSettings
            {
                SmtpServer = builder.Configuration["Email:SmtpServer"],
                Port = builder.Configuration.GetValue<int>("Email:Port"),
                Username = Environment.GetEnvironmentVariable("EMAIL_USERNAME") ?? builder.Configuration["Email:Username"],
                Password = Environment.GetEnvironmentVariable("EMAIL_PASSWORD") ?? builder.Configuration["Email:Password"],
                FromAddress = builder.Configuration["Email:FromAddress"]
            };

            if (string.IsNullOrEmpty(emailSettings.SmtpServer))
            {
                throw new Exception("Email configuration is missing or invalid.");
            }

            #region stripe
            var stripeSettings = new StripeSettings
            {
                Publishablekey = Environment.GetEnvironmentVariable("STRIPE_PUBLISHKEY") ?? builder.Configuration["Stripe:Publishablekey"],
                Secretkey = Environment.GetEnvironmentVariable("STRIPE_SECRETKEY") ?? builder.Configuration["Stripe:Secretkey"],
                WebhookSecret =  builder.Configuration["Stripe:WebhookSecret"],
                SuccessUrl =  builder.Configuration["Stripe:SuccessUrl"],
                CancelUrl =  builder.Configuration["Stripe:CancelUrl"]
            };

            if (string.IsNullOrEmpty(stripeSettings.Secretkey))
            {
                throw new Exception("Stripe configuration is missing or invalid.");
            }

            builder.Services.AddScoped<TokenService>();
            builder.Services.AddScoped<CustomerService>();
            builder.Services.AddScoped<ChargeService>();
            builder.Services.AddScoped<ProductService>();
            builder.Services.AddScoped<PaymentService>();
            builder.Services.AddScoped<InvoiceService>();
            builder.Services.AddScoped<StripeService>();
            builder.Services.AddScoped<OrderService>();
            #endregion


            builder.Services.AddScoped<QRCodeService>();
            builder.Services.AddScoped<ICartService, CartService>();
            builder.Services.AddAutoMapper(typeof(Program));

            // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
            builder.Services.AddEndpointsApiExplorer();
            builder.Services.AddSwaggerGen();
            builder.Services.AddSwaggerGen(swagger =>
            {
                // This is to generate the default UI of Swagger Documentation
                swagger.SwaggerDoc("v1", new OpenApiInfo
                {
                    Version = "v1",
                    Title = "AKhder API",
                    Description = "API for e-commerce platform."
                });

                // To Enable authorization using Swagger (JWT)
                swagger.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme()
                {
                    Name = "Authorization",
                    Type = SecuritySchemeType.ApiKey,
                    Scheme = "Bearer",
                    BearerFormat = "JWT",
                    In = ParameterLocation.Header,
                    Description = "Enter 'Bearer' [space] and then your valid token in the text input below.\r\n\r\nExample: \"Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9\"",
                });
                swagger.AddSecurityRequirement(new OpenApiSecurityRequirement
                {
                    {
                        new OpenApiSecurityScheme
                        {
                            Reference = new OpenApiReference
                            {
                                Type = ReferenceType.SecurityScheme,
                                Id = "Bearer"
                            }
                        },
                        new string[] {}
                    }
                });

            });

            builder.Services.AddSignalR();
            var app = builder.Build();

            // Configure the HTTP request pipeline.
            if (app.Environment.IsProduction() || app.Environment.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
                app.UseSwagger();
                app.UseSwaggerUI(opt =>
                {
                    opt.SwaggerEndpoint("/swagger/v1/swagger.json", "AKhder API v1");
                });
            }

            app.UseHttpsRedirection();

            // Enable CORS
            app.UseCors("AllowAll");

            StripeConfiguration.ApiKey = Environment.GetEnvironmentVariable("STRIPE_SECRETKEY") ?? builder.Configuration.GetSection("Stripe:Secretkey").Get<string>();

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

            app.MapControllers();
            app.MapHub<NotificationHub>("/notificationHub");
            app.Run();
        }
    }
}