Parking owner

.gitignore

@@ -2,3 +2,4 @@
 /obj
 /Migrations/
 /bin
+/wwwroot

Controllers/AuthController.cs

@@ -102,8 +102,9 @@ public async Task<IActionResult> Login([FromBody] LoginDto loginDto)
         var employee = await _context.Employees!.FirstOrDefaultAsync(e => e.Email == loginDto.Email);
         if (employee == null)
         {
-            return BadRequest(new {message = "Invalid credentials"});
+            return BadRequest(new {message = "Invalid credentials", email = employee});
         }
+
 
         if (!BCrypt.Net.BCrypt.Verify(loginDto.Password, employee.Password))
         {
@@ -267,7 +268,6 @@ public async Task<IActionResult> RefreshToken([FromBody] RefreshTokenDto refresh
             if (validatedToken is JwtSecurityToken jwtSecurityToken)
             {
                 var result = jwtSecurityToken.Header.Alg.Equals(SecurityAlgorithms.HmacSha256, StringComparison.InvariantCultureIgnoreCase);
-
                 if (result == false)
                     return null;
             }

Controllers/DriverController.cs

@@ -0,0 +1,245 @@
+using System.IdentityModel.Tokens.Jwt;
+using System.Security.Claims;
+using System.Text;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Options;
+using Microsoft.IdentityModel.Tokens;
+using Server.Configurations;
+using Server.DbContext;
+using server.Helpers;
+using Server.Models;
+using Server.Models.Dto;
+
+namespace Server.Controllers;
+
+[Route("api/[controller]")] 
+[ApiController]
+public class DriverController:ControllerBase
+{
+    private readonly ApplicationDbContext _context;
+    private readonly JWTConfig _jwtConfig;
+    private readonly TokenValidationParameters _tokenValidationParameters;
+
+    public DriverController(ApplicationDbContext context, IOptions<JWTConfig> jwtConfig, TokenValidationParameters tokenValidationParameters)
+    {
+        _context = context;
+        _jwtConfig = jwtConfig.Value;
+        _tokenValidationParameters = tokenValidationParameters;
+    }
+
+
+    private async Task<AuthResults> GenerateJwtToken(Driver driver)
+    {
+        var tokenHandler = new JwtSecurityTokenHandler();
+        var key = Encoding.ASCII.GetBytes(_jwtConfig.Secret);
+
+        var tokenDescriptor = new SecurityTokenDescriptor
+        {
+            Subject = new ClaimsIdentity(new[]
+            {
+                new Claim("Id", driver.DriverId),
+                new Claim(JwtRegisteredClaimNames.Email, driver.Email),
+                new Claim(JwtRegisteredClaimNames.Sub, driver.Email),
+                new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
+            }),
+            Expires = DateTime.UtcNow.Add(_jwtConfig.ExpiryTimeFrame),
+            SigningCredentials =
+                new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
+        };
+
+        var token = tokenHandler.CreateToken(tokenDescriptor);
+        var tokenResult = tokenHandler.WriteToken(token);
+
+        var refreshToken = new DriverRefreshToken()
+        {
+            Id = IdGenerator.GenerateRandomId(60),
+            DriverId = driver.DriverId,
+            Token = RandomString(20) + Guid.NewGuid(),
+            Expires = DateTime.UtcNow.AddMonths(6),
+            IsUsed = false,
+            IsRevoked = false,
+            JwtId = token.Id
+        };
+
+        await _context.DriverRefreshTokens!.AddAsync(refreshToken);
+        await _context.SaveChangesAsync();
+
+        return new AuthResults()
+        {
+            Token = tokenResult,
+            RefreshToken = refreshToken.Token,
+            Result = true,
+            Errors = null
+        };
+    }
+
+    private string RandomString(int length)
+    { 
+        const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz_"; 
+        return new string(Enumerable.Repeat(chars, length)
+            .Select(s => s[new Random().Next(s.Length)]).ToArray());
+    }
+
+    [HttpPost("register")]
+    public async Task<IActionResult> Register([FromBody] DriverDto driver)
+    {
+        if (!ModelState.IsValid)
+        {
+            return BadRequest();
+        }
+
+        var existingDriver = await _context.Drivers!.FirstOrDefaultAsync(d => d.Email == driver.Email);
+        if (existingDriver != null)
+        {
+            return BadRequest(
+                new
+                {
+                    message = "Driver with this email already exists"
+                }
+                );
+        }
+
+        if (driver.Password != driver.ConfirmPassword)
+        {
+            return BadRequest(
+            new{
+                message ="Password and confirm password do not match"
+            });
+
+        }
+
+        var hashedPassword = BCrypt.Net.BCrypt.HashPassword(driver.Password);
+        var newDriver = new Driver
+        {
+            DriverId = IdGenerator.GenerateId("Drv"),
+            Email = driver.Email,
+            Password = hashedPassword,
+            FirstName = driver.FirstName,
+            LastName = driver.LastName,
+            ContactNumber = driver.ContactNumber,
+            AccountCreatedAt = DateTime.UtcNow,
+            Token = ""
+        };
+
+
+
+        await _context.Drivers!.AddAsync(newDriver);
+        await _context.SaveChangesAsync();
+        var jwtToken = await GenerateJwtToken(newDriver);
+        newDriver.Token = jwtToken.Token;
+        await _context.SaveChangesAsync();
+
+        var user = new
+        {
+            Id = newDriver.DriverId,
+            FirstName = newDriver.FirstName,
+            LastName = newDriver.LastName,
+            Email = newDriver.Email,
+            ProfilePicture = "https://i.imgur.com/6VBx3io.png",
+            ContactNumber = newDriver.ContactNumber,
+        };
+        return Ok(new
+        {
+            message = "Login successful",
+            token = jwtToken.Token,
+            driver = user
+
+        });
+    }
+
+    [HttpPost("login")]
+    public async Task<IActionResult> Login([FromBody] LoginDto loginDto)
+    {
+        if (!ModelState.IsValid)
+        {
+            return BadRequest(ModelState);
+        }
+
+        var driver = await _context.Drivers!.FirstOrDefaultAsync(d => d.Email == loginDto.Email);
+        if (driver == null)
+        {
+            return NotFound("Driver with this email does not exist");
+        }
+
+        if (!BCrypt.Net.BCrypt.Verify(loginDto.Password, driver.Password))
+        {
+            return BadRequest("Invalid credentials");
+        }
+
+        var jwtToken = await GenerateJwtToken(driver);
+        driver.Token = jwtToken.Token;
+        await _context.SaveChangesAsync();
+
+        var user = new
+        {
+            Id = driver.DriverId,
+            FirstName = driver.FirstName,
+            LastName = driver.LastName,
+            Email = driver.Email,
+            ProfilePicture = "https://i.imgur.com/6VBx3io.png",
+            ContactNumber = driver.ContactNumber,
+        };
+        return Ok(new
+        {
+            message = "Login successful",
+            token = jwtToken.Token,
+            driver = user
+
+        });
+    }
+
+
+    [HttpPost("add-vehicle")]
+    public async Task<IActionResult> AddVehicle([FromBody] VehicleDto vehicleDto)
+    {
+        if (!ModelState.IsValid)
+        {
+            return BadRequest(ModelState);
+        }
+        var vehicle = _context.Vehicles!.FirstOrDefault(v => v.VehicleNumber == vehicleDto.VehicleNumber);
+        if (vehicle != null)
+        {
+            return BadRequest("Vehicle with this number already exists");
+        }
+
+        var driver = await _context.Drivers!.FirstOrDefaultAsync(d => d.DriverId == "Drv_1365_6410");
+        if (driver == null)
+        {
+            return BadRequest("Driver with this id does not exist");
+        }
+        var newVehicle = new Vehicle
+        {
+            Driver = driver,
+            VehicleNumber = vehicleDto.VehicleNumber,
+            VehicleType = vehicleDto.VehicleType,
+            VehicleModel = vehicleDto.VehicleModel,
+            VehicleAddedAt = DateTime.UtcNow,
+            VehicleColor = vehicleDto.VehicleColor,
+            AdditionalNotes = vehicleDto.AdditionalNotes,
+        };
+        await _context.Vehicles!.AddAsync(newVehicle);
+        await _context.SaveChangesAsync();
+        return Ok(new
+        {
+            message = "Vehicle added successfully",
+        });
+    }
+
+    [HttpGet("get-nearest-park")]
+    [Authorize]
+    public async Task<IActionResult> GetParkingPlaces([FromBody] GetNearestParkDto getNearestParkDto)
+    {
+        if (!ModelState.IsValid)
+        {
+            return BadRequest(ModelState);
+        }
+        var parkingPlaces = await _context.ParkingPlaces!.ToListAsync();
+        return Ok(new
+        {
+            message = "Parking places retrieved successfully",
+            parkingPlaces
+        });
+    }
+}

Controllers/EmailController.cs

@@ -47,6 +47,7 @@ public async Task<IActionResult> VerifyAccountEmail([FromBody] VerifyAccountDto
                                             <p>Hello,</p>
                                             <p>Your account has been created. Your verification code is: {verifyAccountDto.VerificationCode}</p>
                                             <p>Please click the following link to complete your registration: <a href=""http://127.0.0.1:3000/verify-account/{verifyAccountDto.EmployeeId}"">http://127.0.0.1:3000/verify-account/{verifyAccountDto.EmployeeId}</a></p>
+                                            <p>Please click the following link to complete your registration: <a href=""http://localhost:5173/verify-account/{verifyAccountDto.EmployeeId}"">http://localhost:5173/verify-account/{verifyAccountDto.EmployeeId}</a></p>
                                             <p>Best regards,<br>Park Ease Team</p>
                                         </body>
                                     </html>";