Make configuration validation flexible for deployment

- Only validate critical settings (MongoDB, JWT) as errors
- Make Email and Cloudinary settings optional (warnings only)
- Add deployment environment detection
- Create Render.com deployment guide with required environment variables
- Allow application to start with missing optional configuration

Author: Dang

VehicleShowroomManagement/RENDER_DEPLOYMENT.md

@@ -0,0 +1,67 @@
+# Render.com Deployment Guide
+
+## Quick Setup for Render.com
+
+### 1. Set Required Environment Variables
+
+In your Render.com dashboard, go to your service and add these **REQUIRED** environment variables:
+
+```
+MONGODB_CONNECTION_STRING=mongodb+srv://username:[email protected]/VehicleShowroomDB
+JWT_KEY=your-super-secret-jwt-key-that-is-at-least-32-characters-long-for-security
+JWT_ISSUER=VehicleShowroomManagement
+JWT_AUDIENCE=VehicleShowroomManagement-Users
+```
+
+### 2. Optional Environment Variables (for full functionality)
+
+```
+EMAIL_SMTP_HOST=smtp.gmail.com
+EMAIL_SMTP_PORT=587
+[email protected]
+EMAIL_SMTP_PASSWORD=your-app-password
+[email protected]
+EMAIL_FROM_NAME=Vehicle Showroom Management
+
+CLOUDINARY_CLOUD_NAME=your-cloud-name
+CLOUDINARY_API_KEY=your-api-key
+CLOUDINARY_API_SECRET=your-api-secret
+```
+
+### 3. MongoDB Atlas Setup
+
+1. Go to [MongoDB Atlas](https://www.mongodb.com/atlas)
+2. Create a free cluster
+3. Create a database user
+4. Get your connection string
+5. Set `MONGODB_CONNECTION_STRING` in Render.com
+
+### 4. Generate JWT Key
+
+Generate a secure JWT key (32+ characters):
+```bash
+# Option 1: Use online generator
+# Go to: https://generate-secret.vercel.app/32
+
+# Option 2: Use PowerShell
+[System.Web.Security.Membership]::GeneratePassword(32, 0)
+```
+
+### 5. Deploy
+
+Once you've set the required environment variables, your application should deploy successfully!
+
+## What's Fixed
+
+- ✅ Configuration validation now only fails on critical settings (MongoDB, JWT)
+- ✅ Email and Cloudinary settings are optional (warnings only)
+- ✅ Better error messages and deployment guidance
+- ✅ Environment variable mapping improved
+
+## Troubleshooting
+
+If you still get errors:
+1. Check that all 4 required environment variables are set
+2. Verify MongoDB connection string is valid
+3. Ensure JWT key is at least 32 characters
+4. Check Render.com logs for specific error messages

VehicleShowroomManagement/src/Application/Common/Configuration/ConfigurationValidator.cs

@@ -17,10 +17,19 @@ public static async Task<bool> ValidateConfigurationAsync(IConfiguration configu
         {
             var isValid = true;
             var errors = new List<string>();
+            var warnings = new List<string>();
 
             try
             {
-                // Validate MongoDB connection
+                // Check if we're in a deployment environment (Docker/Production)
+                var isDocker = Environment.GetEnvironmentVariable("DOTNET_RUNNING_IN_CONTAINER") == "true";
+                var isProduction = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Production";
+                var isDeployment = isDocker || isProduction;
+
+                logger.LogInformation("Configuration validation - Docker: {IsDocker}, Production: {IsProduction}, Deployment: {IsDeployment}", 
+                    isDocker, isProduction, isDeployment);
+
+                // Validate MongoDB connection (CRITICAL - always required)
                 var mongoConnectionString = configuration.GetConnectionString("MongoDB");
                 if (string.IsNullOrWhiteSpace(mongoConnectionString))
                 {
@@ -43,7 +52,7 @@ public static async Task<bool> ValidateConfigurationAsync(IConfiguration configu
                     }
                 }
 
-                // Validate JWT settings
+                // Validate JWT settings (CRITICAL - always required)
                 var jwtKey = configuration["Jwt:Key"];
                 if (string.IsNullOrWhiteSpace(jwtKey))
                 {
@@ -70,81 +79,90 @@ public static async Task<bool> ValidateConfigurationAsync(IConfiguration configu
                     isValid = false;
                 }
 
-                // Validate Email settings
+                // Validate Email settings (OPTIONAL - warn but don't fail)
                 var smtpHost = configuration["EmailSettings:SmtpHost"];
                 if (string.IsNullOrWhiteSpace(smtpHost))
                 {
-                    errors.Add("Email SMTP Host is missing");
-                    isValid = false;
+                    warnings.Add("Email SMTP Host is missing - email functionality will be disabled");
                 }
 
                 var smtpPort = configuration["EmailSettings:SmtpPort"];
-                if (!int.TryParse(smtpPort, out var port) || port < 1 || port > 65535)
+                if (!string.IsNullOrWhiteSpace(smtpHost) && (!int.TryParse(smtpPort, out var port) || port < 1 || port > 65535))
                 {
-                    errors.Add("Email SMTP Port must be a valid port number (1-65535)");
-                    isValid = false;
+                    warnings.Add("Email SMTP Port must be a valid port number (1-65535)");
                 }
 
                 var smtpUsername = configuration["EmailSettings:SmtpUsername"];
-                if (string.IsNullOrWhiteSpace(smtpUsername))
+                if (string.IsNullOrWhiteSpace(smtpUsername) && !string.IsNullOrWhiteSpace(smtpHost))
                 {
-                    errors.Add("Email SMTP Username is missing");
-                    isValid = false;
+                    warnings.Add("Email SMTP Username is missing - email functionality will be disabled");
                 }
 
                 var smtpPassword = configuration["EmailSettings:SmtpPassword"];
-                if (string.IsNullOrWhiteSpace(smtpPassword))
+                if (string.IsNullOrWhiteSpace(smtpPassword) && !string.IsNullOrWhiteSpace(smtpHost))
                 {
-                    errors.Add("Email SMTP Password is missing");
-                    isValid = false;
+                    warnings.Add("Email SMTP Password is missing - email functionality will be disabled");
                 }
 
                 var fromEmail = configuration["EmailSettings:FromEmail"];
-                if (string.IsNullOrWhiteSpace(fromEmail))
+                if (string.IsNullOrWhiteSpace(fromEmail) && !string.IsNullOrWhiteSpace(smtpHost))
                 {
-                    errors.Add("Email From Email is missing");
-                    isValid = false;
+                    warnings.Add("Email From Email is missing - email functionality will be disabled");
                 }
-                else if (!IsValidEmail(fromEmail))
+                else if (!string.IsNullOrWhiteSpace(fromEmail) && !IsValidEmail(fromEmail))
                 {
-                    errors.Add("Email From Email is not a valid email address");
-                    isValid = false;
+                    warnings.Add("Email From Email is not a valid email address");
                 }
 
-                // Validate Cloudinary settings
+                // Validate Cloudinary settings (OPTIONAL - warn but don't fail)
                 var cloudName = configuration["CloudinarySettings:CloudName"];
                 if (string.IsNullOrWhiteSpace(cloudName))
                 {
-                    errors.Add("Cloudinary Cloud Name is missing");
-                    isValid = false;
+                    warnings.Add("Cloudinary Cloud Name is missing - image upload functionality will be disabled");
                 }
 
                 var apiKey = configuration["CloudinarySettings:ApiKey"];
-                if (string.IsNullOrWhiteSpace(apiKey))
+                if (string.IsNullOrWhiteSpace(apiKey) && !string.IsNullOrWhiteSpace(cloudName))
                 {
-                    errors.Add("Cloudinary API Key is missing");
-                    isValid = false;
+                    warnings.Add("Cloudinary API Key is missing - image upload functionality will be disabled");
                 }
 
                 var apiSecret = configuration["CloudinarySettings:ApiSecret"];
-                if (string.IsNullOrWhiteSpace(apiSecret))
+                if (string.IsNullOrWhiteSpace(apiSecret) && !string.IsNullOrWhiteSpace(cloudName))
                 {
-                    errors.Add("Cloudinary API Secret is missing");
-                    isValid = false;
+                    warnings.Add("Cloudinary API Secret is missing - image upload functionality will be disabled");
                 }
 
                 // Log validation results
                 if (isValid)
                 {
-                    logger.LogInformation("All configuration settings validated successfully");
+                    logger.LogInformation("All critical configuration settings validated successfully");
+                    
+                    if (warnings.Any())
+                    {
+                        logger.LogWarning("Configuration validation completed with {WarningCount} warnings", warnings.Count);
+                        foreach (var warning in warnings)
+                        {
+                            logger.LogWarning("Configuration Warning: {Warning}", warning);
+                        }
+                    }
                 }
                 else
                 {
-                    logger.LogError("Configuration validation failed with {ErrorCount} errors", errors.Count);
+                    logger.LogError("Configuration validation failed with {ErrorCount} critical errors", errors.Count);
                     foreach (var error in errors)
                     {
                         logger.LogError("Configuration Error: {Error}", error);
                     }
+                    
+                    if (warnings.Any())
+                    {
+                        logger.LogWarning("Additional configuration warnings:");
+                        foreach (var warning in warnings)
+                        {
+                            logger.LogWarning("Configuration Warning: {Warning}", warning);
+                        }
+                    }
                 }
             }
             catch (Exception ex)