Add project files.

CarParkValidationAPI/Authorization/AllowAnonymousAttribute.cs

@@ -0,0 +1,8 @@
+using System;
+
+namespace CarParkValidationAPI.Authorization
+{
+    [AttributeUsage(AttributeTargets.Method)]
+    public class AllowAnonymousAttribute : Attribute
+    { }
+}

CarParkValidationAPI/Authorization/AuthorizeAttribute.cs

@@ -0,0 +1,38 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using CarParkValidationAPI.Entities;
+using CarParkValidationAPI.Models;
+
+namespace CarParkValidationAPI.Authorization
+{
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
+    public class AuthorizeAttribute : Attribute, IAuthorizationFilter
+    {
+        private readonly IList<AdminRole> _roles;
+
+        public AuthorizeAttribute(params AdminRole[] roles)
+        {
+            _roles = roles ?? new AdminRole[] { };
+        }
+
+        public void OnAuthorization(AuthorizationFilterContext context)
+        {
+            // skip authorization if action is decorated with [AllowAnonymous] attribute
+            var allowAnonymous = context.ActionDescriptor.EndpointMetadata.OfType<AllowAnonymousAttribute>().Any();
+            if (allowAnonymous)
+                return;
+
+            // authorization
+            var user = (User)context.HttpContext.Items["User"];
+            if (user == null || (_roles.Any() && !_roles.Contains(user.Role)))
+            {
+                // not logged in or role not authorized
+                context.Result = new JsonResult(new { message = "Unauthorized" }) { StatusCode = StatusCodes.Status401Unauthorized };
+            }
+        }
+    }
+}

CarParkValidationAPI/Authorization/JwtMiddleware.cs

@@ -0,0 +1,34 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Options;
+using System.Linq;
+using System.Threading.Tasks;
+using CarParkValidationAPI.Models;
+using CarParkValidationAPI.Repository;
+using CarParkValidationAPI.Interface;
+namespace CarParkValidationAPI.Authorization
+{
+    public class JwtMiddleware
+    {
+        private readonly RequestDelegate _next;
+        private readonly AppSettings _appSettings;
+
+        public JwtMiddleware(RequestDelegate next, IOptions<AppSettings> appSettings)
+        {
+            _next = next;
+            _appSettings = appSettings.Value;
+        }
+
+        public async Task Invoke(HttpContext context, IUserService userService, IJwtUtils jwtUtils)
+        {
+            var token = context.Request.Headers["Authorization"].FirstOrDefault()?.Split(" ").Last();
+            var userId = jwtUtils.ValidateJwtToken(token);
+            if (userId != null)
+            {
+                // attach user to context on successful jwt validation
+                context.Items["User"] = userService.GetById(userId.Value);
+            }
+
+            await _next(context);
+        }
+    }
+}

CarParkValidationAPI/Authorization/JwtUtils.cs

@@ -0,0 +1,76 @@
+using Microsoft.Extensions.Options;
+using Microsoft.IdentityModel.Tokens;
+using System;
+using System.IdentityModel.Tokens.Jwt;
+using System.Linq;
+using System.Security.Claims;
+using System.Text;
+using CarParkValidationAPI.Entities;
+using CarParkValidationAPI.Interface;
+using CarParkValidationAPI.Models;
+
+namespace CarParkValidationAPI.Authorization
+{
+   
+
+    public class JwtUtils : IJwtUtils
+    {
+        private readonly AppSettings _appSettings;
+
+        public JwtUtils(IOptions<AppSettings> appSettings)
+        {
+            _appSettings = appSettings.Value;
+        }
+
+        public string GenerateJwtToken(User user)
+        {
+            // generate token that is valid for 2 days
+            var tokenHandler = new JwtSecurityTokenHandler();
+            var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
+            var tokenDescriptor = new SecurityTokenDescriptor
+            {
+                Subject = new ClaimsIdentity(new[] { 
+                  new Claim("id", user.Id.ToString()) 
+                  //add more if we need it
+                }
+                ),
+                Expires = DateTime.UtcNow.AddDays(2),
+                SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
+            };
+            var token = tokenHandler.CreateToken(tokenDescriptor);
+            return tokenHandler.WriteToken(token);
+        }
+
+        public int? ValidateJwtToken(string token)
+        {
+            if (token == null)
+                return null;
+
+            var tokenHandler = new JwtSecurityTokenHandler();
+            var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
+            try
+            {
+                tokenHandler.ValidateToken(token, new TokenValidationParameters
+                {
+                    ValidateIssuerSigningKey = true,
+                    IssuerSigningKey = new SymmetricSecurityKey(key),
+                    ValidateIssuer = false,
+                    ValidateAudience = false,
+                    // set clockskew to zero so tokens expire exactly at token expiration time (instead of 5 minutes later)
+                    ClockSkew = TimeSpan.Zero
+                }, out SecurityToken validatedToken);
+
+                var jwtToken = (JwtSecurityToken)validatedToken;
+                var userId = int.Parse(jwtToken.Claims.First(x => x.Type == "id").Value);
+
+                // return user id from JWT token if validation successful
+                return userId;
+            }
+            catch
+            {
+                // return null if validation fails
+                return null;
+            }
+        }
+    }
+}