put in ignore file

API/FamilyTreeAPI/Authorization/AllowAnonymousAttribute.cs

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

API/FamilyTreeAPI/Authorization/AuthorizeAttribute.cs

@@ -0,0 +1,36 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+
+namespace FamilyTreeAPI.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 };
+        //}
+    }
+}

API/FamilyTreeAPI/Authorization/JwtMiddleware.cs

@@ -0,0 +1,38 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Options;
+using System.Linq;
+using System.Threading.Tasks;
+
+using FamilyTreeAPI.Interface;
+using FamilyTreeAPI.Entities;
+
+namespace FamilyTreeAPI.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, IJwtUtils jwtUtils)
+    {
+        var token = context.Request.Headers["Authorization"].FirstOrDefault()?.Split(" ").Last();
+        if (token != null)
+        {
+            var user = jwtUtils.ValidateJwtToken(token);
+            if (user != null)
+            {
+                // attach user to context on successful jwt validation
+                //here to put in the real user 
+                //TODO if you want to add information for User
+                context.Items["User"] = user;
+            }
+        }
+        await _next(context);
+    }
+}

API/FamilyTreeAPI/Authorization/JwtUtils.cs

@@ -0,0 +1,111 @@
+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 FamilyTreeAPI.Entities;
+using FamilyTreeAPI.Interface;
+
+namespace FamilyTreeAPI.Authorization;
+
+
+public class JwtUtils : IJwtUtils
+{
+    private readonly AppSettings _appSettings;
+
+    public JwtUtils(IOptions<AppSettings> appSettings)
+    {
+        _appSettings = appSettings.Value;
+    }
+
+    public string GenerateJwtToken(UserDto 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()),
+              new Claim("subject", user.Username),
+              new Claim("firstName", user.FirstName + " " + user.LastName)
+              {
+
+              }
+
+              //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);
+    }
+    // get back id and username. in subject
+    public UserDto? 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); //old
+            int userId = 0;
+            string username = "";
+            string firstName = "";
+            Claim claim;
+            for (int i = 0; i< jwtToken.Claims.Count(); i++)
+            {
+                claim = jwtToken.Claims.ElementAt(i);
+                if (claim.Type == "id")
+                {
+                    userId = int.Parse(claim.Value);
+                }
+                else if (claim.Type == "subject")
+                {
+                    username = claim.Value;
+                }
+                else if (claim.Type == "firstName")
+                {
+                    firstName = claim.Value;
+                }
+
+                if (!string.IsNullOrEmpty(username) 
+                    && !string.IsNullOrEmpty(firstName)
+                    && userId > 0)
+                {
+                    break;
+                }
+            }
+
+            UserDto user = new UserDto();
+            user.Id = userId;
+            user.Username = username;
+            user.FirstName = firstName;
+            
+            // return user id from JWT token if validation successful
+            return user;
+        }
+        catch
+        {
+            // return null if validation fails
+            return null;
+        }
+    }
+}