From 70eac8a9c8aef5b6d0eb1aa3548ebd797418b9aa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C4=90=C4=83ng=20Nguy=E1=BB=85n?= <dangnv2512@gmail.com>
Date: Fri, 26 Sep 2025 09:37:06 +0700
Subject: [PATCH] update identity

---
 RobotApp.Client/Layout/MainLayout.razor       |   2 +-
 RobotApp.Client/Layout/NavMenu.razor          |  16 +-
 RobotApp/Data/ApplicationDbContext.cs         |   1 -
 RobotApp/Data/ApplicationDbExtensions.cs      |  54 ++
 ...000000000_CreateIdentitySchema.Designer.cs |  22 +-
 .../00000000000000_CreateIdentitySchema.cs    |  22 +-
 .../20250926020848_initDb.Designer.cs         | 268 +++++++
 .../Data/Migrations/20250926020848_initDb.cs  | 721 ++++++++++++++++++
 .../ApplicationDbContextModelSnapshot.cs      | 235 +++---
 RobotApp/Modbus/RegisterOrder.cs              |   8 -
 RobotApp/Program.cs                           |   5 +-
 RobotApp/RobotApp.csproj                      |   8 +-
 .../Exceptions}/ModbusException.cs            |   2 +-
 .../{Modbus => Services}/ModbusTcpClient.cs   |  55 +-
 RobotApp/robot.db                             | Bin 0 -> 167936 bytes
 15 files changed, 1219 insertions(+), 200 deletions(-)
 create mode 100644 RobotApp/Data/ApplicationDbExtensions.cs
 create mode 100644 RobotApp/Data/Migrations/20250926020848_initDb.Designer.cs
 create mode 100644 RobotApp/Data/Migrations/20250926020848_initDb.cs
 delete mode 100644 RobotApp/Modbus/RegisterOrder.cs
 rename RobotApp/{Modbus => Services/Exceptions}/ModbusException.cs (86%)
 rename RobotApp/{Modbus => Services}/ModbusTcpClient.cs (85%)
 create mode 100644 RobotApp/robot.db

diff --git a/RobotApp.Client/Layout/MainLayout.razor b/RobotApp.Client/Layout/MainLayout.razor
index e0abdd1..81e3cf1 100644
--- a/RobotApp.Client/Layout/MainLayout.razor
+++ b/RobotApp.Client/Layout/MainLayout.razor
@@ -1,5 +1,5 @@
 @inherits LayoutComponentBase
-
+@using MudBlazor
 
 <div class="app-shell">
     <AuthorizeView>
diff --git a/RobotApp.Client/Layout/NavMenu.razor b/RobotApp.Client/Layout/NavMenu.razor
index cab99df..9e1e064 100644
--- a/RobotApp.Client/Layout/NavMenu.razor
+++ b/RobotApp.Client/Layout/NavMenu.razor
@@ -1,4 +1,6 @@
-<script>
+@using Microsoft.AspNetCore.Components.Routing
+
+<script>
     function toggleSidebar() {
         let sidebar = document.querySelector(".sidebar");
         sidebar.classList.toggle("collapsed");
@@ -43,17 +45,7 @@
 
     public NavModel[] Navs = [
         new(){Icon = "mdi-view-dashboard", Path="/", Label = "Dashboard", Match = NavLinkMatch.All},
-        new(){Icon = "mdi-file-cog", Path="/", Label = "Script Manager", Match = NavLinkMatch.All},
-        new(){Icon = "mdi-file-code", Path="/", Label = "Script Editor", Match = NavLinkMatch.All},
-        new(){Icon = "mdi-flag-checkered", Path="/", Label = "Missions", Match = NavLinkMatch.All},
-        new(){Icon = "mdi-map-legend", Path="/", Label = "Maps", Match = NavLinkMatch.All},
-        new(){Icon = "mdi-robot-mower", Path="/", Label = "Robots", Match = NavLinkMatch.All},
-        new(){Icon = "mdi-robot-industrial", Path="/", Label = "Robot Models", Match = NavLinkMatch.All},
-        new(){Icon = "mdi-monitor-eye", Path="/", Label = "Monitor", Match = NavLinkMatch.All},
-        new(){Icon = "mdi-traffic-light", Path="/", Label = "Traffic", Match = NavLinkMatch.All},
-        new(){Icon = "mdi-factory", Path="/", Label = "Open ACS", Match = NavLinkMatch.All},
-        new(){Icon = "mdi-math-log", Path="/", Label = "Logs", Match = NavLinkMatch.All},
-        new(){Icon = "mdi-account", Path="/", Label = "User", Match = NavLinkMatch.All},
+        new(){Icon = "mdi-map-legend", Path="/", Label = "Maps-manager", Match = NavLinkMatch.All},
     ];
 
     private bool collapseNavMenu = true;
diff --git a/RobotApp/Data/ApplicationDbContext.cs b/RobotApp/Data/ApplicationDbContext.cs
index 6a58b6e..e1bc9ad 100644
--- a/RobotApp/Data/ApplicationDbContext.cs
+++ b/RobotApp/Data/ApplicationDbContext.cs
@@ -8,6 +8,5 @@ namespace RobotApp.Data
         public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options)
         {
         }
-
     }
 }
diff --git a/RobotApp/Data/ApplicationDbExtensions.cs b/RobotApp/Data/ApplicationDbExtensions.cs
new file mode 100644
index 0000000..7b4383d
--- /dev/null
+++ b/RobotApp/Data/ApplicationDbExtensions.cs
@@ -0,0 +1,54 @@
+using Microsoft.AspNetCore.Identity;
+using Microsoft.EntityFrameworkCore;
+
+namespace RobotApp.Data;
+
+public static class ApplicationDbExtensions
+{
+    public static async Task SeedApplicationDbAsync(this IServiceProvider serviceProvider)
+    {
+        using var scope = serviceProvider.GetRequiredService<IServiceScopeFactory>().CreateScope();
+
+        using var appDb = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
+
+        await appDb.Database.MigrateAsync();
+        //await appDb.Database.EnsureCreatedAsync();
+        await appDb.SaveChangesAsync();
+
+        await scope.ServiceProvider.SeedRolesAsync();
+        await scope.ServiceProvider.SeedUsersAsync();
+    }
+
+    private static async Task SeedRolesAsync(this IServiceProvider serviceProvider)
+    {
+        var roleManager = serviceProvider.GetRequiredService<RoleManager<ApplicationRole>>();
+
+        if (!await roleManager.RoleExistsAsync("Administrator"))
+        {
+            await roleManager.CreateAsync(new ApplicationRole()
+            {
+                Name = "Administrator",
+                NormalizedName = "ADMINISTRATOR",
+            });
+        }
+    }
+
+    private static async Task SeedUsersAsync(this IServiceProvider serviceProvider)
+    {
+        using var userManager = serviceProvider.GetRequiredService<UserManager<ApplicationUser>>();
+        if (await userManager.FindByNameAsync("admin") is null)
+        {
+            var admin = new ApplicationUser()
+            {
+                UserName = "admin",
+                Email = "administrator@phenikaa-x.com",
+                NormalizedUserName = "ADMINISTRATOR",
+                NormalizedEmail = "ADMINISTRATOR@PHENIKAA-X.COM",
+                EmailConfirmed = true,
+            };
+
+            await userManager.CreateAsync(admin, "robotics");
+            await userManager.AddToRoleAsync(admin, "Administrator");
+        }
+    }
+}
diff --git a/RobotApp/Data/Migrations/00000000000000_CreateIdentitySchema.Designer.cs b/RobotApp/Data/Migrations/00000000000000_CreateIdentitySchema.Designer.cs
index ea472ef..e9aeabb 100644
--- a/RobotApp/Data/Migrations/00000000000000_CreateIdentitySchema.Designer.cs
+++ b/RobotApp/Data/Migrations/00000000000000_CreateIdentitySchema.Designer.cs
@@ -35,7 +35,7 @@ namespace RobotApp.Migrations
 
                     b.Property<string>("ConcurrencyStamp")
                         .IsConcurrencyToken()
-                        .HasColumnType("nvarchar(max)");
+                        .HasColumnType("Text");
 
                     b.Property<string>("Email")
                         .HasMaxLength(256)
@@ -59,16 +59,16 @@ namespace RobotApp.Migrations
                         .HasColumnType("nvarchar(256)");
 
                     b.Property<string>("PasswordHash")
-                        .HasColumnType("nvarchar(max)");
+                        .HasColumnType("Text");
 
                     b.Property<string>("PhoneNumber")
-                        .HasColumnType("nvarchar(max)");
+                        .HasColumnType("Text");
 
                     b.Property<bool>("PhoneNumberConfirmed")
                         .HasColumnType("bit");
 
                     b.Property<string>("SecurityStamp")
-                        .HasColumnType("nvarchar(max)");
+                        .HasColumnType("Text");
 
                     b.Property<bool>("TwoFactorEnabled")
                         .HasColumnType("bit");
@@ -97,7 +97,7 @@ namespace RobotApp.Migrations
 
                     b.Property<string>("ConcurrencyStamp")
                         .IsConcurrencyToken()
-                        .HasColumnType("nvarchar(max)");
+                        .HasColumnType("Text");
 
                     b.Property<string>("Name")
                         .HasMaxLength(256)
@@ -126,10 +126,10 @@ namespace RobotApp.Migrations
                     SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
 
                     b.Property<string>("ClaimType")
-                        .HasColumnType("nvarchar(max)");
+                        .HasColumnType("Text");
 
                     b.Property<string>("ClaimValue")
-                        .HasColumnType("nvarchar(max)");
+                        .HasColumnType("Text");
 
                     b.Property<string>("RoleId")
                         .IsRequired()
@@ -151,10 +151,10 @@ namespace RobotApp.Migrations
                     SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
 
                     b.Property<string>("ClaimType")
-                        .HasColumnType("nvarchar(max)");
+                        .HasColumnType("Text");
 
                     b.Property<string>("ClaimValue")
-                        .HasColumnType("nvarchar(max)");
+                        .HasColumnType("Text");
 
                     b.Property<string>("UserId")
                         .IsRequired()
@@ -176,7 +176,7 @@ namespace RobotApp.Migrations
                         .HasColumnType("nvarchar(450)");
 
                     b.Property<string>("ProviderDisplayName")
-                        .HasColumnType("nvarchar(max)");
+                        .HasColumnType("Text");
 
                     b.Property<string>("UserId")
                         .IsRequired()
@@ -216,7 +216,7 @@ namespace RobotApp.Migrations
                         .HasColumnType("nvarchar(450)");
 
                     b.Property<string>("Value")
-                        .HasColumnType("nvarchar(max)");
+                        .HasColumnType("Text");
 
                     b.HasKey("UserId", "LoginProvider", "Name");
 
diff --git a/RobotApp/Data/Migrations/00000000000000_CreateIdentitySchema.cs b/RobotApp/Data/Migrations/00000000000000_CreateIdentitySchema.cs
index e525594..e2c70b6 100644
--- a/RobotApp/Data/Migrations/00000000000000_CreateIdentitySchema.cs
+++ b/RobotApp/Data/Migrations/00000000000000_CreateIdentitySchema.cs
@@ -18,7 +18,7 @@ namespace RobotApp.Migrations
                     Id = table.Column<string>(type: "nvarchar(450)", nullable: false),
                     Name = table.Column<string>(type: "nvarchar(256)", maxLength: 256, nullable: true),
                     NormalizedName = table.Column<string>(type: "nvarchar(256)", maxLength: 256, nullable: true),
-                    ConcurrencyStamp = table.Column<string>(type: "nvarchar(max)", nullable: true)
+                    ConcurrencyStamp = table.Column<string>(type: "Text", nullable: true)
                 },
                 constraints: table =>
                 {
@@ -35,10 +35,10 @@ namespace RobotApp.Migrations
                     Email = table.Column<string>(type: "nvarchar(256)", maxLength: 256, nullable: true),
                     NormalizedEmail = table.Column<string>(type: "nvarchar(256)", maxLength: 256, nullable: true),
                     EmailConfirmed = table.Column<bool>(type: "bit", nullable: false),
-                    PasswordHash = table.Column<string>(type: "nvarchar(max)", nullable: true),
-                    SecurityStamp = table.Column<string>(type: "nvarchar(max)", nullable: true),
-                    ConcurrencyStamp = table.Column<string>(type: "nvarchar(max)", nullable: true),
-                    PhoneNumber = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    PasswordHash = table.Column<string>(type: "Text", nullable: true),
+                    SecurityStamp = table.Column<string>(type: "Text", nullable: true),
+                    ConcurrencyStamp = table.Column<string>(type: "Text", nullable: true),
+                    PhoneNumber = table.Column<string>(type: "Text", nullable: true),
                     PhoneNumberConfirmed = table.Column<bool>(type: "bit", nullable: false),
                     TwoFactorEnabled = table.Column<bool>(type: "bit", nullable: false),
                     LockoutEnd = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: true),
@@ -57,8 +57,8 @@ namespace RobotApp.Migrations
                     Id = table.Column<int>(type: "int", nullable: false)
                         .Annotation("SqlServer:Identity", "1, 1"),
                     RoleId = table.Column<string>(type: "nvarchar(450)", nullable: false),
-                    ClaimType = table.Column<string>(type: "nvarchar(max)", nullable: true),
-                    ClaimValue = table.Column<string>(type: "nvarchar(max)", nullable: true)
+                    ClaimType = table.Column<string>(type: "Text", nullable: true),
+                    ClaimValue = table.Column<string>(type: "Text", nullable: true)
                 },
                 constraints: table =>
                 {
@@ -78,8 +78,8 @@ namespace RobotApp.Migrations
                     Id = table.Column<int>(type: "int", nullable: false)
                         .Annotation("SqlServer:Identity", "1, 1"),
                     UserId = table.Column<string>(type: "nvarchar(450)", nullable: false),
-                    ClaimType = table.Column<string>(type: "nvarchar(max)", nullable: true),
-                    ClaimValue = table.Column<string>(type: "nvarchar(max)", nullable: true)
+                    ClaimType = table.Column<string>(type: "Text", nullable: true),
+                    ClaimValue = table.Column<string>(type: "Text", nullable: true)
                 },
                 constraints: table =>
                 {
@@ -98,7 +98,7 @@ namespace RobotApp.Migrations
                 {
                     LoginProvider = table.Column<string>(type: "nvarchar(450)", nullable: false),
                     ProviderKey = table.Column<string>(type: "nvarchar(450)", nullable: false),
-                    ProviderDisplayName = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    ProviderDisplayName = table.Column<string>(type: "Text", nullable: true),
                     UserId = table.Column<string>(type: "nvarchar(450)", nullable: false)
                 },
                 constraints: table =>
@@ -143,7 +143,7 @@ namespace RobotApp.Migrations
                     UserId = table.Column<string>(type: "nvarchar(450)", nullable: false),
                     LoginProvider = table.Column<string>(type: "nvarchar(450)", nullable: false),
                     Name = table.Column<string>(type: "nvarchar(450)", nullable: false),
-                    Value = table.Column<string>(type: "nvarchar(max)", nullable: true)
+                    Value = table.Column<string>(type: "Text", nullable: true)
                 },
                 constraints: table =>
                 {
diff --git a/RobotApp/Data/Migrations/20250926020848_initDb.Designer.cs b/RobotApp/Data/Migrations/20250926020848_initDb.Designer.cs
new file mode 100644
index 0000000..e81f01b
--- /dev/null
+++ b/RobotApp/Data/Migrations/20250926020848_initDb.Designer.cs
@@ -0,0 +1,268 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using RobotApp.Data;
+
+#nullable disable
+
+namespace RobotApp.Data.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20250926020848_initDb")]
+    partial class initDb
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "9.0.9");
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("RobotApp.Data.ApplicationRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("RobotApp.Data.ApplicationUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("RobotApp.Data.ApplicationRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("RobotApp.Data.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("RobotApp.Data.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("RobotApp.Data.ApplicationRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("RobotApp.Data.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("RobotApp.Data.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/RobotApp/Data/Migrations/20250926020848_initDb.cs b/RobotApp/Data/Migrations/20250926020848_initDb.cs
new file mode 100644
index 0000000..085e636
--- /dev/null
+++ b/RobotApp/Data/Migrations/20250926020848_initDb.cs
@@ -0,0 +1,721 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace RobotApp.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class initDb : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropIndex(
+                name: "UserNameIndex",
+                table: "AspNetUsers");
+
+            migrationBuilder.DropIndex(
+                name: "RoleNameIndex",
+                table: "AspNetRoles");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Value",
+                table: "AspNetUserTokens",
+                type: "TEXT",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "Text",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Name",
+                table: "AspNetUserTokens",
+                type: "TEXT",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(450)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "LoginProvider",
+                table: "AspNetUserTokens",
+                type: "TEXT",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(450)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "UserId",
+                table: "AspNetUserTokens",
+                type: "TEXT",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(450)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "UserName",
+                table: "AspNetUsers",
+                type: "TEXT",
+                maxLength: 256,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(256)",
+                oldMaxLength: 256,
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<bool>(
+                name: "TwoFactorEnabled",
+                table: "AspNetUsers",
+                type: "INTEGER",
+                nullable: false,
+                oldClrType: typeof(bool),
+                oldType: "bit");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "SecurityStamp",
+                table: "AspNetUsers",
+                type: "TEXT",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "Text",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<bool>(
+                name: "PhoneNumberConfirmed",
+                table: "AspNetUsers",
+                type: "INTEGER",
+                nullable: false,
+                oldClrType: typeof(bool),
+                oldType: "bit");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "PhoneNumber",
+                table: "AspNetUsers",
+                type: "TEXT",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "Text",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "PasswordHash",
+                table: "AspNetUsers",
+                type: "TEXT",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "Text",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "NormalizedUserName",
+                table: "AspNetUsers",
+                type: "TEXT",
+                maxLength: 256,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(256)",
+                oldMaxLength: 256,
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "NormalizedEmail",
+                table: "AspNetUsers",
+                type: "TEXT",
+                maxLength: 256,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(256)",
+                oldMaxLength: 256,
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<DateTimeOffset>(
+                name: "LockoutEnd",
+                table: "AspNetUsers",
+                type: "TEXT",
+                nullable: true,
+                oldClrType: typeof(DateTimeOffset),
+                oldType: "datetimeoffset",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<bool>(
+                name: "LockoutEnabled",
+                table: "AspNetUsers",
+                type: "INTEGER",
+                nullable: false,
+                oldClrType: typeof(bool),
+                oldType: "bit");
+
+            migrationBuilder.AlterColumn<bool>(
+                name: "EmailConfirmed",
+                table: "AspNetUsers",
+                type: "INTEGER",
+                nullable: false,
+                oldClrType: typeof(bool),
+                oldType: "bit");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Email",
+                table: "AspNetUsers",
+                type: "TEXT",
+                maxLength: 256,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(256)",
+                oldMaxLength: 256,
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "ConcurrencyStamp",
+                table: "AspNetUsers",
+                type: "TEXT",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "Text",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<int>(
+                name: "AccessFailedCount",
+                table: "AspNetUsers",
+                type: "INTEGER",
+                nullable: false,
+                oldClrType: typeof(int),
+                oldType: "int");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Id",
+                table: "AspNetUsers",
+                type: "TEXT",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(450)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "RoleId",
+                table: "AspNetUserRoles",
+                type: "TEXT",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(450)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "UserId",
+                table: "AspNetUserRoles",
+                type: "TEXT",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(450)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "UserId",
+                table: "AspNetUserLogins",
+                type: "TEXT",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(450)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "ProviderDisplayName",
+                table: "AspNetUserLogins",
+                type: "TEXT",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "Text",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "ProviderKey",
+                table: "AspNetUserLogins",
+                type: "TEXT",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(450)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "LoginProvider",
+                table: "AspNetUserLogins",
+                type: "TEXT",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(450)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "UserId",
+                table: "AspNetUserClaims",
+                type: "TEXT",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(450)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "ClaimValue",
+                table: "AspNetUserClaims",
+                type: "TEXT",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "Text",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "ClaimType",
+                table: "AspNetUserClaims",
+                type: "TEXT",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "Text",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<int>(
+                name: "Id",
+                table: "AspNetUserClaims",
+                type: "INTEGER",
+                nullable: false,
+                oldClrType: typeof(int),
+                oldType: "int")
+                .Annotation("Sqlite:Autoincrement", true)
+                .OldAnnotation("Sqlite:Autoincrement", true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "NormalizedName",
+                table: "AspNetRoles",
+                type: "TEXT",
+                maxLength: 256,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(256)",
+                oldMaxLength: 256,
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Name",
+                table: "AspNetRoles",
+                type: "TEXT",
+                maxLength: 256,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(256)",
+                oldMaxLength: 256,
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "ConcurrencyStamp",
+                table: "AspNetRoles",
+                type: "TEXT",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "Text",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Id",
+                table: "AspNetRoles",
+                type: "TEXT",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(450)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "RoleId",
+                table: "AspNetRoleClaims",
+                type: "TEXT",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(450)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "ClaimValue",
+                table: "AspNetRoleClaims",
+                type: "TEXT",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "Text",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "ClaimType",
+                table: "AspNetRoleClaims",
+                type: "TEXT",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "Text",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<int>(
+                name: "Id",
+                table: "AspNetRoleClaims",
+                type: "INTEGER",
+                nullable: false,
+                oldClrType: typeof(int),
+                oldType: "int")
+                .Annotation("Sqlite:Autoincrement", true)
+                .OldAnnotation("Sqlite:Autoincrement", true);
+
+            migrationBuilder.CreateIndex(
+                name: "UserNameIndex",
+                table: "AspNetUsers",
+                column: "NormalizedUserName",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "RoleNameIndex",
+                table: "AspNetRoles",
+                column: "NormalizedName",
+                unique: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropIndex(
+                name: "UserNameIndex",
+                table: "AspNetUsers");
+
+            migrationBuilder.DropIndex(
+                name: "RoleNameIndex",
+                table: "AspNetRoles");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Value",
+                table: "AspNetUserTokens",
+                type: "Text",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "TEXT",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Name",
+                table: "AspNetUserTokens",
+                type: "nvarchar(450)",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "TEXT");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "LoginProvider",
+                table: "AspNetUserTokens",
+                type: "nvarchar(450)",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "TEXT");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "UserId",
+                table: "AspNetUserTokens",
+                type: "nvarchar(450)",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "TEXT");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "UserName",
+                table: "AspNetUsers",
+                type: "nvarchar(256)",
+                maxLength: 256,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "TEXT",
+                oldMaxLength: 256,
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<bool>(
+                name: "TwoFactorEnabled",
+                table: "AspNetUsers",
+                type: "bit",
+                nullable: false,
+                oldClrType: typeof(bool),
+                oldType: "INTEGER");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "SecurityStamp",
+                table: "AspNetUsers",
+                type: "Text",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "TEXT",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<bool>(
+                name: "PhoneNumberConfirmed",
+                table: "AspNetUsers",
+                type: "bit",
+                nullable: false,
+                oldClrType: typeof(bool),
+                oldType: "INTEGER");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "PhoneNumber",
+                table: "AspNetUsers",
+                type: "Text",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "TEXT",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "PasswordHash",
+                table: "AspNetUsers",
+                type: "Text",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "TEXT",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "NormalizedUserName",
+                table: "AspNetUsers",
+                type: "nvarchar(256)",
+                maxLength: 256,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "TEXT",
+                oldMaxLength: 256,
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "NormalizedEmail",
+                table: "AspNetUsers",
+                type: "nvarchar(256)",
+                maxLength: 256,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "TEXT",
+                oldMaxLength: 256,
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<DateTimeOffset>(
+                name: "LockoutEnd",
+                table: "AspNetUsers",
+                type: "datetimeoffset",
+                nullable: true,
+                oldClrType: typeof(DateTimeOffset),
+                oldType: "TEXT",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<bool>(
+                name: "LockoutEnabled",
+                table: "AspNetUsers",
+                type: "bit",
+                nullable: false,
+                oldClrType: typeof(bool),
+                oldType: "INTEGER");
+
+            migrationBuilder.AlterColumn<bool>(
+                name: "EmailConfirmed",
+                table: "AspNetUsers",
+                type: "bit",
+                nullable: false,
+                oldClrType: typeof(bool),
+                oldType: "INTEGER");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Email",
+                table: "AspNetUsers",
+                type: "nvarchar(256)",
+                maxLength: 256,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "TEXT",
+                oldMaxLength: 256,
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "ConcurrencyStamp",
+                table: "AspNetUsers",
+                type: "Text",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "TEXT",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<int>(
+                name: "AccessFailedCount",
+                table: "AspNetUsers",
+                type: "int",
+                nullable: false,
+                oldClrType: typeof(int),
+                oldType: "INTEGER");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Id",
+                table: "AspNetUsers",
+                type: "nvarchar(450)",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "TEXT");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "RoleId",
+                table: "AspNetUserRoles",
+                type: "nvarchar(450)",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "TEXT");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "UserId",
+                table: "AspNetUserRoles",
+                type: "nvarchar(450)",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "TEXT");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "UserId",
+                table: "AspNetUserLogins",
+                type: "nvarchar(450)",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "TEXT");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "ProviderDisplayName",
+                table: "AspNetUserLogins",
+                type: "Text",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "TEXT",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "ProviderKey",
+                table: "AspNetUserLogins",
+                type: "nvarchar(450)",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "TEXT");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "LoginProvider",
+                table: "AspNetUserLogins",
+                type: "nvarchar(450)",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "TEXT");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "UserId",
+                table: "AspNetUserClaims",
+                type: "nvarchar(450)",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "TEXT");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "ClaimValue",
+                table: "AspNetUserClaims",
+                type: "Text",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "TEXT",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "ClaimType",
+                table: "AspNetUserClaims",
+                type: "Text",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "TEXT",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<int>(
+                name: "Id",
+                table: "AspNetUserClaims",
+                type: "int",
+                nullable: false,
+                oldClrType: typeof(int),
+                oldType: "INTEGER")
+                .Annotation("Sqlite:Autoincrement", true)
+                .OldAnnotation("Sqlite:Autoincrement", true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "NormalizedName",
+                table: "AspNetRoles",
+                type: "nvarchar(256)",
+                maxLength: 256,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "TEXT",
+                oldMaxLength: 256,
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Name",
+                table: "AspNetRoles",
+                type: "nvarchar(256)",
+                maxLength: 256,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "TEXT",
+                oldMaxLength: 256,
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "ConcurrencyStamp",
+                table: "AspNetRoles",
+                type: "Text",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "TEXT",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Id",
+                table: "AspNetRoles",
+                type: "nvarchar(450)",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "TEXT");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "RoleId",
+                table: "AspNetRoleClaims",
+                type: "nvarchar(450)",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "TEXT");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "ClaimValue",
+                table: "AspNetRoleClaims",
+                type: "Text",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "TEXT",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "ClaimType",
+                table: "AspNetRoleClaims",
+                type: "Text",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "TEXT",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<int>(
+                name: "Id",
+                table: "AspNetRoleClaims",
+                type: "int",
+                nullable: false,
+                oldClrType: typeof(int),
+                oldType: "INTEGER")
+                .Annotation("Sqlite:Autoincrement", true)
+                .OldAnnotation("Sqlite:Autoincrement", true);
+
+            migrationBuilder.CreateIndex(
+                name: "UserNameIndex",
+                table: "AspNetUsers",
+                column: "NormalizedUserName",
+                unique: true,
+                filter: "[NormalizedUserName] IS NOT NULL");
+
+            migrationBuilder.CreateIndex(
+                name: "RoleNameIndex",
+                table: "AspNetRoles",
+                column: "NormalizedName",
+                unique: true,
+                filter: "[NormalizedName] IS NOT NULL");
+        }
+    }
+}
diff --git a/RobotApp/Data/Migrations/ApplicationDbContextModelSnapshot.cs b/RobotApp/Data/Migrations/ApplicationDbContextModelSnapshot.cs
index 4515ae9..3f45751 100644
--- a/RobotApp/Data/Migrations/ApplicationDbContextModelSnapshot.cs
+++ b/RobotApp/Data/Migrations/ApplicationDbContextModelSnapshot.cs
@@ -1,8 +1,7 @@
-// <auto-generated />
+// <auto-generated />
 using System;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.EntityFrameworkCore.Metadata;
 using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
 using RobotApp.Data;
 
@@ -16,121 +15,23 @@ namespace RobotApp.Migrations
         protected override void BuildModel(ModelBuilder modelBuilder)
         {
 #pragma warning disable 612, 618
-            modelBuilder
-                .HasAnnotation("ProductVersion", "8.0.0")
-                .HasAnnotation("Relational:MaxIdentifierLength", 128);
-
-            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
-
-            modelBuilder.Entity("RobotApp.Data.ApplicationUser", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("nvarchar(450)");
-
-                    b.Property<int>("AccessFailedCount")
-                        .HasColumnType("int");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .HasColumnType("nvarchar(max)");
-
-                    b.Property<string>("Email")
-                        .HasMaxLength(256)
-                        .HasColumnType("nvarchar(256)");
-
-                    b.Property<bool>("EmailConfirmed")
-                        .HasColumnType("bit");
-
-                    b.Property<bool>("LockoutEnabled")
-                        .HasColumnType("bit");
-
-                    b.Property<DateTimeOffset?>("LockoutEnd")
-                        .HasColumnType("datetimeoffset");
-
-                    b.Property<string>("NormalizedEmail")
-                        .HasMaxLength(256)
-                        .HasColumnType("nvarchar(256)");
-
-                    b.Property<string>("NormalizedUserName")
-                        .HasMaxLength(256)
-                        .HasColumnType("nvarchar(256)");
-
-                    b.Property<string>("PasswordHash")
-                        .HasColumnType("nvarchar(max)");
-
-                    b.Property<string>("PhoneNumber")
-                        .HasColumnType("nvarchar(max)");
-
-                    b.Property<bool>("PhoneNumberConfirmed")
-                        .HasColumnType("bit");
-
-                    b.Property<string>("SecurityStamp")
-                        .HasColumnType("nvarchar(max)");
-
-                    b.Property<bool>("TwoFactorEnabled")
-                        .HasColumnType("bit");
-
-                    b.Property<string>("UserName")
-                        .HasMaxLength(256)
-                        .HasColumnType("nvarchar(256)");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("NormalizedEmail")
-                        .HasDatabaseName("EmailIndex");
-
-                    b.HasIndex("NormalizedUserName")
-                        .IsUnique()
-                        .HasDatabaseName("UserNameIndex")
-                        .HasFilter("[NormalizedUserName] IS NOT NULL");
-
-                    b.ToTable("AspNetUsers", (string)null);
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("nvarchar(450)");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .HasColumnType("nvarchar(max)");
-
-                    b.Property<string>("Name")
-                        .HasMaxLength(256)
-                        .HasColumnType("nvarchar(256)");
-
-                    b.Property<string>("NormalizedName")
-                        .HasMaxLength(256)
-                        .HasColumnType("nvarchar(256)");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("NormalizedName")
-                        .IsUnique()
-                        .HasDatabaseName("RoleNameIndex")
-                        .HasFilter("[NormalizedName] IS NOT NULL");
-
-                    b.ToTable("AspNetRoles", (string)null);
-                });
+            modelBuilder.HasAnnotation("ProductVersion", "9.0.9");
 
             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
                 {
                     b.Property<int>("Id")
                         .ValueGeneratedOnAdd()
-                        .HasColumnType("int");
-
-                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+                        .HasColumnType("INTEGER");
 
                     b.Property<string>("ClaimType")
-                        .HasColumnType("nvarchar(max)");
+                        .HasColumnType("TEXT");
 
                     b.Property<string>("ClaimValue")
-                        .HasColumnType("nvarchar(max)");
+                        .HasColumnType("TEXT");
 
                     b.Property<string>("RoleId")
                         .IsRequired()
-                        .HasColumnType("nvarchar(450)");
+                        .HasColumnType("TEXT");
 
                     b.HasKey("Id");
 
@@ -143,19 +44,17 @@ namespace RobotApp.Migrations
                 {
                     b.Property<int>("Id")
                         .ValueGeneratedOnAdd()
-                        .HasColumnType("int");
-
-                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+                        .HasColumnType("INTEGER");
 
                     b.Property<string>("ClaimType")
-                        .HasColumnType("nvarchar(max)");
+                        .HasColumnType("TEXT");
 
                     b.Property<string>("ClaimValue")
-                        .HasColumnType("nvarchar(max)");
+                        .HasColumnType("TEXT");
 
                     b.Property<string>("UserId")
                         .IsRequired()
-                        .HasColumnType("nvarchar(450)");
+                        .HasColumnType("TEXT");
 
                     b.HasKey("Id");
 
@@ -167,17 +66,17 @@ namespace RobotApp.Migrations
             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
                 {
                     b.Property<string>("LoginProvider")
-                        .HasColumnType("nvarchar(450)");
+                        .HasColumnType("TEXT");
 
                     b.Property<string>("ProviderKey")
-                        .HasColumnType("nvarchar(450)");
+                        .HasColumnType("TEXT");
 
                     b.Property<string>("ProviderDisplayName")
-                        .HasColumnType("nvarchar(max)");
+                        .HasColumnType("TEXT");
 
                     b.Property<string>("UserId")
                         .IsRequired()
-                        .HasColumnType("nvarchar(450)");
+                        .HasColumnType("TEXT");
 
                     b.HasKey("LoginProvider", "ProviderKey");
 
@@ -189,10 +88,10 @@ namespace RobotApp.Migrations
             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
                 {
                     b.Property<string>("UserId")
-                        .HasColumnType("nvarchar(450)");
+                        .HasColumnType("TEXT");
 
                     b.Property<string>("RoleId")
-                        .HasColumnType("nvarchar(450)");
+                        .HasColumnType("TEXT");
 
                     b.HasKey("UserId", "RoleId");
 
@@ -204,25 +103,115 @@ namespace RobotApp.Migrations
             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
                 {
                     b.Property<string>("UserId")
-                        .HasColumnType("nvarchar(450)");
+                        .HasColumnType("TEXT");
 
                     b.Property<string>("LoginProvider")
-                        .HasColumnType("nvarchar(450)");
+                        .HasColumnType("TEXT");
 
                     b.Property<string>("Name")
-                        .HasColumnType("nvarchar(450)");
+                        .HasColumnType("TEXT");
 
                     b.Property<string>("Value")
-                        .HasColumnType("nvarchar(max)");
+                        .HasColumnType("TEXT");
 
                     b.HasKey("UserId", "LoginProvider", "Name");
 
                     b.ToTable("AspNetUserTokens", (string)null);
                 });
 
+            modelBuilder.Entity("RobotApp.Data.ApplicationRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("RobotApp.Data.ApplicationUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
                 {
-                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                    b.HasOne("RobotApp.Data.ApplicationRole", null)
                         .WithMany()
                         .HasForeignKey("RoleId")
                         .OnDelete(DeleteBehavior.Cascade)
@@ -249,7 +238,7 @@ namespace RobotApp.Migrations
 
             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
                 {
-                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                    b.HasOne("RobotApp.Data.ApplicationRole", null)
                         .WithMany()
                         .HasForeignKey("RoleId")
                         .OnDelete(DeleteBehavior.Cascade)
diff --git a/RobotApp/Modbus/RegisterOrder.cs b/RobotApp/Modbus/RegisterOrder.cs
deleted file mode 100644
index 401fbd4..0000000
--- a/RobotApp/Modbus/RegisterOrder.cs
+++ /dev/null
@@ -1,8 +0,0 @@
-namespace RobotApp.Modbus;
-
-
-public enum RegisterOrder 
-{
-    LowHigh = 0,
-    HighLow = 1 
-}
diff --git a/RobotApp/Program.cs b/RobotApp/Program.cs
index 0b0d385..e81d55c 100644
--- a/RobotApp/Program.cs
+++ b/RobotApp/Program.cs
@@ -2,7 +2,6 @@ using Microsoft.AspNetCore.Components.Authorization;
 using Microsoft.AspNetCore.Identity;
 using Microsoft.EntityFrameworkCore;
 using MudBlazor.Services;
-using RobotApp.Client.Pages;
 using RobotApp.Components;
 using RobotApp.Components.Account;
 using RobotApp.Data;
@@ -23,9 +22,6 @@ builder.Services.AddScoped<AuthenticationStateProvider, IdentityRevalidatingAuth
 builder.Services.AddMudServices();
 builder.Services.AddAuthorization();
 
-var connectionString = builder.Configuration.GetConnectionString("DefaultConnection")
-    ?? throw new InvalidOperationException("Connection string 'DefaultConnection' not found.");
-
 var connectionString = builder.Configuration.GetConnectionString("DefaultConnection") ?? throw new InvalidOperationException("Connection string 'DefaultConnection' not found.");
 Action<DbContextOptionsBuilder> appDbOptions = options => options.UseSqlite(connectionString, b => b.MigrationsAssembly("RobotApp"));
 
@@ -50,6 +46,7 @@ builder.Services.AddSingleton<RobotConnection>();
 builder.Services.AddHostedService(sp => sp.GetRequiredService<RobotConnection>());
 
 var app = builder.Build();
+await app.Services.SeedApplicationDbAsync();
 
 // Configure the HTTP request pipeline.
 if (app.Environment.IsDevelopment())
diff --git a/RobotApp/RobotApp.csproj b/RobotApp/RobotApp.csproj
index 165725f..2e851d5 100644
--- a/RobotApp/RobotApp.csproj
+++ b/RobotApp/RobotApp.csproj
@@ -7,6 +7,13 @@
     <UserSecretsId>aspnet-RobotApp-1f61caa2-bbbb-40cd-88b6-409b408a84ea</UserSecretsId>
   </PropertyGroup>
 
+  <ItemGroup>
+    <Compile Remove="Layout\**" />
+    <Content Remove="Layout\**" />
+    <EmbeddedResource Remove="Layout\**" />
+    <None Remove="Layout\**" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\RobotApp.Client\RobotApp.Client.csproj" />
     <ProjectReference Include="..\RobotApp.Common.Shares\RobotApp.Common.Shares.csproj" />
@@ -24,7 +31,6 @@
   </ItemGroup>
 
   <ItemGroup>
-    <Folder Include="Layout\" />
     <Folder Include="Services\Robot\Simulation\" />
     <Folder Include="wwwroot\lib\" />
   </ItemGroup>
diff --git a/RobotApp/Modbus/ModbusException.cs b/RobotApp/Services/Exceptions/ModbusException.cs
similarity index 86%
rename from RobotApp/Modbus/ModbusException.cs
rename to RobotApp/Services/Exceptions/ModbusException.cs
index 665b664..136495c 100644
--- a/RobotApp/Modbus/ModbusException.cs
+++ b/RobotApp/Services/Exceptions/ModbusException.cs
@@ -1,4 +1,4 @@
-namespace RobotApp.Modbus;
+namespace RobotApp.Services.Exceptions;
 
 public class ModbusException : Exception
 {
diff --git a/RobotApp/Modbus/ModbusTcpClient.cs b/RobotApp/Services/ModbusTcpClient.cs
similarity index 85%
rename from RobotApp/Modbus/ModbusTcpClient.cs
rename to RobotApp/Services/ModbusTcpClient.cs
index b101acf..ee5c547 100644
--- a/RobotApp/Modbus/ModbusTcpClient.cs
+++ b/RobotApp/Services/ModbusTcpClient.cs
@@ -1,8 +1,9 @@
 using Microsoft.AspNetCore.Connections;
+using RobotApp.Services.Exceptions;
 using System.Net;
 using System.Net.Sockets;
 
-namespace RobotApp.Modbus;
+namespace RobotApp.Services;
 
 public class ModbusTcpClient(string IpAddress, int Port, byte ClientId) : IDisposable
 {
@@ -100,9 +101,9 @@ public class ModbusTcpClient(string IpAddress, int Port, byte ClientId) : IDispo
         }
     }
 
-    private byte[] Write(byte functionCode, UInt16 startingAddress, UInt16 quantity, CancellationToken? cancellationToken = null)
+    private byte[] Write(byte functionCode, ushort startingAddress, ushort quantity, CancellationToken? cancellationToken = null)
         => Write(functionCode, startingAddress, quantity, [], cancellationToken);
-    private byte[] Write(byte functionCode, UInt16 startingAddress, UInt16 quantity, byte[] multipleData, CancellationToken? cancellationToken = null)
+    private byte[] Write(byte functionCode, ushort startingAddress, ushort quantity, byte[] multipleData, CancellationToken? cancellationToken = null)
     {
         try
         {
@@ -176,43 +177,43 @@ public class ModbusTcpClient(string IpAddress, int Port, byte ClientId) : IDispo
         }
     }
 
-    public bool[] ReadDiscreteInputs(UInt16 startingAddress, UInt16 quantity, CancellationToken? cancellationToken = null)
+    public bool[] ReadDiscreteInputs(ushort startingAddress, ushort quantity, CancellationToken? cancellationToken = null)
     {
         if (startingAddress > 65535 | quantity > 2000)
         {
             throw new ArgumentException("Starting address must be 0 - 65535; quantity must be 0 - 2000");
         }
         var data = Write(0x02, startingAddress, quantity, cancellationToken);
-        if (data.Length - 1 < ((quantity - 1) / 8)) return [];
+        if (data.Length - 1 < (quantity - 1) / 8) return [];
         bool[] response = new bool[quantity];
         for (int i = 0; i < quantity; i++)
         {
             int intData = data[i / 8];
-            int mask = Convert.ToInt32(Math.Pow(2, (i % 8)));
+            int mask = Convert.ToInt32(Math.Pow(2, i % 8));
             response[i] = Convert.ToBoolean((intData & mask) / mask);
         }
         return response;
     }
 
-    public bool[] ReadCoils(UInt16 startingAddress, UInt16 quantity, CancellationToken? cancellationToken = null)
+    public bool[] ReadCoils(ushort startingAddress, ushort quantity, CancellationToken? cancellationToken = null)
     {
         if (startingAddress > 65535 | quantity > 2000)
         {
             throw new ArgumentException("Starting address must be 0 - 65535; quantity must be 0 - 2000");
         }
         var data = Write(0x01, startingAddress, quantity, cancellationToken);
-        if (data.Length - 1 < ((quantity - 1) / 8)) return [];
+        if (data.Length - 1 < (quantity - 1) / 8) return [];
         bool[] response = new bool[quantity];
         for (int i = 0; i < quantity; i++)
         {
             int intData = data[i / 8];
-            int mask = Convert.ToInt32(Math.Pow(2, (i % 8)));
+            int mask = Convert.ToInt32(Math.Pow(2, i % 8));
             response[i] = Convert.ToBoolean((intData & mask) / mask);
         }
-        return (response);
+        return response;
     }
 
-    public int[] ReadHoldingRegisters(UInt16 startingAddress, UInt16 quantity, CancellationToken? cancellationToken = null)
+    public int[] ReadHoldingRegisters(ushort startingAddress, ushort quantity, CancellationToken? cancellationToken = null)
     {
         if (startingAddress > 65535 | quantity > 125)
         {
@@ -223,12 +224,12 @@ public class ModbusTcpClient(string IpAddress, int Port, byte ClientId) : IDispo
         int[] response = new int[quantity];
         for (int i = 0; i < quantity; i++)
         {
-            response[i] = (data[i * 2] << 8) | data[i * 2 + 1];
+            response[i] = data[i * 2] << 8 | data[i * 2 + 1];
         }
-        return (response);
+        return response;
     }
 
-    public int[] ReadInputRegisters(UInt16 startingAddress, UInt16 quantity, CancellationToken? cancellationToken = null)
+    public int[] ReadInputRegisters(ushort startingAddress, ushort quantity, CancellationToken? cancellationToken = null)
     {
         if (startingAddress > 65535 | quantity > 125)
         {
@@ -239,22 +240,22 @@ public class ModbusTcpClient(string IpAddress, int Port, byte ClientId) : IDispo
         int[] response = new int[quantity];
         for (int i = 0; i < quantity; i++)
         {
-            response[i] = (data[i * 2] << 8) | data[i * 2 + 1];
+            response[i] = data[i * 2] << 8 | data[i * 2 + 1];
         }
-        return (response);
+        return response;
     }
 
-    public void WriteSingleCoil(UInt16 startingAddress, bool value, CancellationToken? cancellationToken = null)
+    public void WriteSingleCoil(ushort startingAddress, bool value, CancellationToken? cancellationToken = null)
     {
-        Write(0x05, startingAddress, value ? (UInt16)0xFF00 : (UInt16)0x0000, cancellationToken);
+        Write(0x05, startingAddress, value ? (ushort)0xFF00 : (ushort)0x0000, cancellationToken);
     }
 
-    public void WriteSingleRegister(UInt16 startingAddress, UInt16 value, CancellationToken? cancellationToken = null)
+    public void WriteSingleRegister(ushort startingAddress, ushort value, CancellationToken? cancellationToken = null)
     {
         Write(0x06, startingAddress, value, cancellationToken);
     }
 
-    public void WriteMultipleCoils(UInt16 startingAddress, bool[] values, CancellationToken? cancellationToken = null)
+    public void WriteMultipleCoils(ushort startingAddress, bool[] values, CancellationToken? cancellationToken = null)
     {
         if (values == null || values.Length == 0)
             throw new ArgumentException("Values cannot be null or empty", nameof(values));
@@ -272,13 +273,13 @@ public class ModbusTcpClient(string IpAddress, int Port, byte ClientId) : IDispo
         {
             if (values[i])
             {
-                data[1 + (i / 8)] |= (byte)(1 << (i % 8));
+                data[1 + i / 8] |= (byte)(1 << i % 8);
             }
         }
-        Write(0x0F, startingAddress, (UInt16)values.Length, data, cancellationToken);
+        Write(0x0F, startingAddress, (ushort)values.Length, data, cancellationToken);
     }
 
-    public void WriteMultipleRegisters(UInt16 startingAddress, UInt16[] values, CancellationToken? cancellationToken = null)
+    public void WriteMultipleRegisters(ushort startingAddress, ushort[] values, CancellationToken? cancellationToken = null)
     {
         if (values == null || values.Length == 0)
             throw new ArgumentException("Values cannot be null or empty", nameof(values));
@@ -297,10 +298,10 @@ public class ModbusTcpClient(string IpAddress, int Port, byte ClientId) : IDispo
             data[1 + i * 2] = (byte)(values[i] >> 8);      
             data[2 + i * 2] = (byte)(values[i] & 0xFF); 
         }
-        Write(0x10, startingAddress, (UInt16)values.Length, data, cancellationToken);
+        Write(0x10, startingAddress, (ushort)values.Length, data, cancellationToken);
     }
 
-    public int[] ReadWriteMultipleRegisters(UInt16 startingAddressRead, UInt16 quantityRead, UInt16 startingAddressWrite, UInt16[] values, CancellationToken? cancellationToken = null)
+    public int[] ReadWriteMultipleRegisters(ushort startingAddressRead, ushort quantityRead, ushort startingAddressWrite, ushort[] values, CancellationToken? cancellationToken = null)
     {
         if (values == null || values.Length == 0)
             throw new ArgumentException("Values cannot be null or empty", nameof(values));
@@ -329,7 +330,7 @@ public class ModbusTcpClient(string IpAddress, int Port, byte ClientId) : IDispo
         var response = new int[quantityRead];
         for (int i = 0; i < quantityRead; i++)
         {
-            response[i] = (receivedData[i * 2] << 8) | receivedData[i * 2 + 1];
+            response[i] = receivedData[i * 2] << 8 | receivedData[i * 2 + 1];
         }
         return response;
     }
@@ -337,7 +338,7 @@ public class ModbusTcpClient(string IpAddress, int Port, byte ClientId) : IDispo
     public bool Available(int timeout)
     {
         System.Net.NetworkInformation.Ping pingSender = new ();
-        IPAddress address = System.Net.IPAddress.Parse(IpAddress);
+        IPAddress address = IPAddress.Parse(IpAddress);
 
         string data = "phenikaaX";
         byte[] buffer = System.Text.Encoding.ASCII.GetBytes(data);
diff --git a/RobotApp/robot.db b/RobotApp/robot.db
new file mode 100644
index 0000000000000000000000000000000000000000..9d7869eca5aa5df0ce9bef83bd6309719c6b12df
GIT binary patch
literal 167936
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
E0p@8sTL1t6

literal 0
HcmV?d00001