Migration works

backend/Api/Api.csproj

@@ -10,6 +10,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="8.0.14" />
     <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.3" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="9.0.3">
       <PrivateAssets>all</PrivateAssets>

backend/Api/Controllers/DeviceController.cs

@@ -15,7 +15,7 @@ namespace Api.Controllers
             _context = context;
         }
 
-
+        // For at få json webtokens til at virke skriv [Authorize] over de endpoints
         [HttpGet]
         public async Task<IActionResult> GetDevices(int userId)
         {

backend/Api/Controllers/UserController.cs

@@ -1,6 +1,10 @@
 using Microsoft.AspNetCore.Mvc;
 using Api.Models;
 using Api.DBAccess;
+using Microsoft.IdentityModel.Tokens;
+using System.IdentityModel.Tokens.Jwt;
+using System.Security.Claims;
+using System.Text;
 
 namespace Api.Controllers
 {
@@ -9,10 +13,12 @@ namespace Api.Controllers
     public class UserController : Controller
     {
         private readonly DBContext _context;
+        private readonly IConfiguration _configuration;
 
-        public UserController(DBContext context)
+        public UserController(DBContext context, IConfiguration configuration)
         {
             _context = context;
+            _configuration = configuration;
         }
 
         [HttpPost("Login")]
@@ -20,8 +26,9 @@ namespace Api.Controllers
         {
             DbAccess dBAccess = new DbAccess(_context);
             user = await dBAccess.Login(user);
-            if (user.Id == 0) { return BadRequest(new { error = "User can't be logged in" }); }
+            if (user.Id == 0) { return Unauthorized(new { error = "Invalid username or password" }); }
-            return Ok(user);
+            var token = GenerateJwtToken(user);
+            return Ok(new { token, user.UserName, user.Id });
         }
 
         [HttpPost("Create")]
@@ -41,5 +48,37 @@ namespace Api.Controllers
             if (!success) { return BadRequest(new { error = "User can't be edited" }); }
             return Ok();
         }
+
+        [HttpDelete("Delete/{userId}")]
+        public async Task<IActionResult> DeleteUser(int userId)
+        {
+            DbAccess dbAccess = new DbAccess(_context);
+            bool success = await dbAccess.DeleteUser(userId);
+            if (!success) { return BadRequest(new { error = "User can't be deleted" }); }
+            return Ok();
+        }
+
+        private string GenerateJwtToken(User user)
+        {
+            var claims = new[]
+            {
+                new Claim(JwtRegisteredClaimNames.Sub, user.Id.ToString()),
+                new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
+                new Claim(ClaimTypes.Name, user.UserName)
+            };
+
+            var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes
+            (_configuration["JwtSettings:Key"]));
+            var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
+
+            var token = new JwtSecurityToken(
+                _configuration["JwtSettings:Issuer"],
+                _configuration["JwtSettings:Audience"],
+                claims,
+                expires: DateTime.Now.AddMinutes(30),
+                signingCredentials: creds);
+
+            return new JwtSecurityTokenHandler().WriteToken(token);
+        }
     }
 }

backend/Api/DBAccess/DBAccess.cs

@@ -1,5 +1,8 @@
 using Microsoft.EntityFrameworkCore;
 using Api.Models;
+using System.Text;
+using System.Runtime.Intrinsics.Arm;
+using System.Security.Cryptography;
 
 
 namespace Api.DBAccess
@@ -28,6 +31,11 @@ namespace Api.DBAccess
             {
                 user.Devices = new List<Device>();
             }
+            string salt = Guid.NewGuid().ToString();
+            string hashedPassword = ComputeHash(user.Password, SHA256.Create(), salt);
+
+            user.Salt = salt;
+            user.Password = hashedPassword;
 
             _context.Users.Add(user);
             return await _context.SaveChangesAsync() == 1;
@@ -36,10 +44,11 @@ namespace Api.DBAccess
         public async Task<User> Login(User user)
         {
             var profile = await _context.Users.FirstAsync(u => u.UserName == user.UserName);
+            
+            string hashedPassword = ComputeHash(user.Password, SHA256.Create(), profile.Salt);
 
-            if (profile.Password == user.Password)
+            if (hashedPassword == user.Password)
             {
-                profile.Password = "";
                 return profile;
             }
             return new User();
@@ -58,6 +67,25 @@ namespace Api.DBAccess
             return await _context.SaveChangesAsync() == 1;
         }
 
+        public async Task<bool> DeleteUser(int userId)
+        {
+            var user = await _context.Users.Include(u => u.Devices).FirstOrDefaultAsync(u => u.Id == userId);
+            if (user != null)
+            {
+                if (user.Devices != null && user.Devices.Count > 0) 
+                {
+                    foreach (var item in user.Devices)
+                    {
+                        var device = await _context.Devices.Include(d => d.Logs).FirstOrDefaultAsync(d => d.Id == item.Id);
+                        if (device != null) { _context.Devices.Remove(device); }
+                    }
+                }
+                _context.Users.Remove(user);
+                return await _context.SaveChangesAsync() == 1;
+            }
+            return false;
+        }
+
         public async Task<List<Device>> ReadDevices(int userId)
         {
             var user = await _context.Users.Include(u => u.Devices).FirstOrDefaultAsync(u => u.Id == userId);
@@ -82,6 +110,21 @@ namespace Api.DBAccess
             return await _context.SaveChangesAsync() == 1;
         }
 
+        public async Task<bool> UpdateDevice(Device device, int deviceId)
+        {
+            var device1 = await _context.Devices.FirstAsync(u => u.Id == deviceId);
+
+            device1.TempLow = device.TempLow;
+
+            device1.TempHigh = device.TempHigh;
+
+            device1.ReferenceId = device.ReferenceId;
+
+            device1.Name = device.Name;
+
+            return await _context.SaveChangesAsync() == 1;
+        }
+
         public async Task<List<TemperatureLogs>> ReadLogs(int deviceId)
         {
             var device = await _context.Devices.Include(d => d.Logs).FirstOrDefaultAsync(d => d.Id == deviceId);
@@ -93,17 +136,19 @@ namespace Api.DBAccess
             return logs;
         }
 
-        public async Task<bool> UpdateDevice(Device device, int deviceId)
+        private static string ComputeHash(string input, HashAlgorithm algorithm, string salt)
         {
-            var device1 = await _context.Devices.FirstAsync(u => u.Id == deviceId);
+            Byte[] inputBytes = Encoding.UTF8.GetBytes(input);
+            Byte[] saltBytes = Encoding.UTF8.GetBytes(salt);
 
-            device1.TempLow = device.TempLow;
+            // Combine salt and input bytes
+            Byte[] saltedInput = new Byte[saltBytes.Length + inputBytes.Length];
+            saltBytes.CopyTo(saltedInput, 0);
+            inputBytes.CopyTo(saltedInput, saltBytes.Length);
 
-            device1.TempHigh = device.TempHigh;
+            Byte[] hashedBytes = algorithm.ComputeHash(saltedInput);
 
-            device1.ReferenceId = device.ReferenceId;
+            return BitConverter.ToString(hashedBytes);
-
-            return await _context.SaveChangesAsync() == 1;
         }
     }
 }

backend/Api/Migrations/20250319124149_AddedSaltUserNameDevice.Designer.cs

@@ -0,0 +1,132 @@
+// <auto-generated />
+using System;
+using Api;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Api.Migrations
+{
+    [DbContext(typeof(DBContext))]
+    [Migration("20250319124149_AddedSaltUserNameDevice")]
+    partial class AddedSaltUserNameDevice
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "9.0.3");
+
+            modelBuilder.Entity("Api.Models.Device", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ReferenceId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<double>("TempHigh")
+                        .HasColumnType("REAL");
+
+                    b.Property<double>("TempLow")
+                        .HasColumnType("REAL");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Devices");
+                });
+
+            modelBuilder.Entity("Api.Models.TemperatureLogs", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("DeviceId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<double>("TempHigh")
+                        .HasColumnType("REAL");
+
+                    b.Property<double>("TempLow")
+                        .HasColumnType("REAL");
+
+                    b.Property<double>("Temperature")
+                        .HasColumnType("REAL");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeviceId");
+
+                    b.ToTable("TemperatureLogs");
+                });
+
+            modelBuilder.Entity("Api.Models.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Password")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Salt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("Api.Models.Device", b =>
+                {
+                    b.HasOne("Api.Models.User", null)
+                        .WithMany("Devices")
+                        .HasForeignKey("UserId");
+                });
+
+            modelBuilder.Entity("Api.Models.TemperatureLogs", b =>
+                {
+                    b.HasOne("Api.Models.Device", null)
+                        .WithMany("Logs")
+                        .HasForeignKey("DeviceId");
+                });
+
+            modelBuilder.Entity("Api.Models.Device", b =>
+                {
+                    b.Navigation("Logs");
+                });
+
+            modelBuilder.Entity("Api.Models.User", b =>
+                {
+                    b.Navigation("Devices");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

backend/Api/Migrations/20250319124149_AddedSaltUserNameDevice.cs

@@ -0,0 +1,39 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Api.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddedSaltUserNameDevice : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "Salt",
+                table: "Users",
+                type: "TEXT",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "Name",
+                table: "Devices",
+                type: "TEXT",
+                nullable: false,
+                defaultValue: "");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "Salt",
+                table: "Users");
+
+            migrationBuilder.DropColumn(
+                name: "Name",
+                table: "Devices");
+        }
+    }
+}

backend/Api/Migrations/DBContextModelSnapshot.cs

@@ -17,12 +17,16 @@ namespace Api.Migrations
 #pragma warning disable 612, 618
             modelBuilder.HasAnnotation("ProductVersion", "9.0.3");
 
-            modelBuilder.Entity("Models.Device", b =>
+            modelBuilder.Entity("Api.Models.Device", b =>
                 {
                     b.Property<int>("Id")
                         .ValueGeneratedOnAdd()
                         .HasColumnType("INTEGER");
 
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
                     b.Property<string>("ReferenceId")
                         .HasColumnType("TEXT");
 
@@ -42,7 +46,7 @@ namespace Api.Migrations
                     b.ToTable("Devices");
                 });
 
-            modelBuilder.Entity("Models.TemperatureLogs", b =>
+            modelBuilder.Entity("Api.Models.TemperatureLogs", b =>
                 {
                     b.Property<int>("Id")
                         .ValueGeneratedOnAdd()
@@ -70,7 +74,7 @@ namespace Api.Migrations
                     b.ToTable("TemperatureLogs");
                 });
 
-            modelBuilder.Entity("Models.User", b =>
+            modelBuilder.Entity("Api.Models.User", b =>
                 {
                     b.Property<int>("Id")
                         .ValueGeneratedOnAdd()
@@ -84,6 +88,9 @@ namespace Api.Migrations
                         .IsRequired()
                         .HasColumnType("TEXT");
 
+                    b.Property<string>("Salt")
+                        .HasColumnType("TEXT");
+
                     b.Property<string>("UserName")
                         .IsRequired()
                         .HasColumnType("TEXT");
@@ -93,26 +100,26 @@ namespace Api.Migrations
                     b.ToTable("Users");
                 });
 
-            modelBuilder.Entity("Models.Device", b =>
+            modelBuilder.Entity("Api.Models.Device", b =>
                 {
-                    b.HasOne("Models.User", null)
+                    b.HasOne("Api.Models.User", null)
                         .WithMany("Devices")
                         .HasForeignKey("UserId");
                 });
 
-            modelBuilder.Entity("Models.TemperatureLogs", b =>
+            modelBuilder.Entity("Api.Models.TemperatureLogs", b =>
                 {
-                    b.HasOne("Models.Device", null)
+                    b.HasOne("Api.Models.Device", null)
                         .WithMany("Logs")
                         .HasForeignKey("DeviceId");
                 });
 
-            modelBuilder.Entity("Models.Device", b =>
+            modelBuilder.Entity("Api.Models.Device", b =>
                 {
                     b.Navigation("Logs");
                 });
 
-            modelBuilder.Entity("Models.User", b =>
+            modelBuilder.Entity("Api.Models.User", b =>
                 {
                     b.Navigation("Devices");
                 });

backend/Api/Models/Device.cs

@@ -4,6 +4,8 @@
     {
         public int Id { get; set; }
 
+        public string Name { get; set; }
+
         public double TempHigh { get; set; }
 
         public double TempLow { get; set; }

backend/Api/Models/User.cs

@@ -10,6 +10,8 @@
 
         public string Email { get; set; }
 
+        public string? Salt { get; set; }
+
         public List<Device>? Devices { get; set; }
     }
 }

backend/Api/Program.cs

@@ -2,14 +2,28 @@ using Api;
 using Microsoft.AspNetCore;
 using Microsoft.EntityFrameworkCore;
 
-var app = WebHost.CreateDefaultBuilder(args)
+class Program
-	.UseUrls("http://0.0.0.0:5000")
+{
-	.UseStartup<Startup>()
+    public static void Main(string[] args)
-	.Build();
+    {
+        var app = CreateWebHostBuilder(args).Build();
 
-await using var scope = app.Services.CreateAsyncScope();
+        RunMigrations(app);
-await using var db = scope.ServiceProvider.GetService<DBContext>();
+
-await db.Database.MigrateAsync();
+        app.Run();
+    }
+    // Calls the startup class and creates the webinterface
+    public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
+        WebHost.CreateDefaultBuilder(args)
+                .UseUrls("0.0.0.0:5000")
+                .UseStartup<Startup>();
+
+    public static async void RunMigrations(IWebHost app)
+    {
+        await using var scope = app.Services.CreateAsyncScope();
+        await using var db = scope.ServiceProvider.GetService<DbContext>();
+        await db.Database.MigrateAsync();
+    }
+}
 
-app.Run();
 

backend/Api/Startup.cs

@@ -1,5 +1,8 @@
-using Microsoft.EntityFrameworkCore;
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.IdentityModel.Tokens;
 using Microsoft.OpenApi.Models;
+using System.Text;
 
 namespace Api
 {
@@ -22,6 +25,29 @@ namespace Api
             
             services.AddControllers();
 
+            services.AddAuthentication(x =>
+            {
+                x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
+                x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
+                x.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
+            }).AddJwtBearer(x =>
+            {
+                x.TokenValidationParameters = new TokenValidationParameters
+                {
+                    ValidIssuer = _configuration["JwtSettings:Issuer"],
+                    ValidAudience = _configuration["JwtSettings:Audience"],
+                    IssuerSigningKey = new SymmetricSecurityKey
+                    (
+                    Encoding.UTF8.GetBytes(_configuration["JwtSettings:Key"])
+                    ),
+                    ValidateIssuer = true,
+                    ValidateAudience = true,
+                    ValidateLifetime = true,
+                    ValidateIssuerSigningKey = true
+                };
+            });
+
+
             services.AddCors(options =>
             {
                 options.AddPolicy("AllowAll", builder =>