(B) Add seed for users, fix constant values issues

Clinics.Backend/API/SeedDatabaseHelper/SeedAdminUserHelper.cs

@@ -14,7 +14,7 @@ public class SeedAdminUserHelper
     {
         using (var serviceScope = applicationBuilder.ApplicationServices.CreateScope())
         {
-            var seedAdminUser = serviceScope.ServiceProvider.GetRequiredService<ISeedAdminUser>();
+            var seedAdminUser = serviceScope.ServiceProvider.GetRequiredService<ISeedUsers>();
             await seedAdminUser.Seed();
         }
     }

Clinics.Backend/API/SeedDatabaseHelper/SeedHelper.cs

@@ -25,7 +25,7 @@ public class SeedHelper
             var seedMedicineForms = serviceScope.ServiceProvider.GetRequiredService<ISeed<MedicineForm>>();
             await seedMedicineForms.Seed();
 
-            var seedUserRoles = serviceScope.ServiceProvider.GetRequiredService<ISeed<Role>>();
+            var seedUserRoles = serviceScope.ServiceProvider.GetRequiredService<ISeed<UserRole>>();
             await seedUserRoles.Seed();
         }
     }

Clinics.Backend/Application/Users/Commands/Login/LoginCommandHandler.cs

@@ -38,7 +38,7 @@ public class LoginCommandHandler : CommandHandlerBase<LoginCommand, LoginRespons
         #region 2. Generate Response
 
         #region 2.1. Admin
-        if (user.Role == Roles.Admin)
+        if (user.Role == UsersRoles.Admin)
         {
             var token = _jwtProvider.Generate(user);
             return LoginResponse.GetResponse(token);
@@ -46,7 +46,7 @@ public class LoginCommandHandler : CommandHandlerBase<LoginCommand, LoginRespons
         #endregion
 
         #region 2.2. Doctor
-        if (user.Role == Roles.Doctor)
+        if (user.Role == UsersRoles.Doctor)
         {
             var doctorUserResult = await _userRepository.GetDoctorUserByUserNameFullAsync(user.UserName);
             if (doctorUserResult.IsFailure)
@@ -58,7 +58,7 @@ public class LoginCommandHandler : CommandHandlerBase<LoginCommand, LoginRespons
         #endregion
 
         #region 2.3. Receptionist user
-        if (user.Role == Roles.Receptionist)
+        if (user.Role == UsersRoles.Receptionist)
         {
             var receptionistUser = await _userRepository.GetReceptionistUserByUserNameFullAsync(user.UserName);
             if (receptionistUser.IsFailure)

Clinics.Backend/Domain/Entities/Identity/UserRoles/Role.cs → Clinics.Backend/Domain/Entities/Identity/UserRoles/UserRole.cs

@@ -2,14 +2,14 @@
 
 namespace Domain.Entities.Identity.UserRoles;
 
-public sealed class Role : Entity
+public sealed class UserRole : Entity
 {
     #region Private ctor
-    private Role(int id) : base(id)
+    private UserRole(int id) : base(id)
     {
     }
 
-    private Role(int id, string name) : base(id)
+    private UserRole(int id, string name) : base(id)
     {
         Name = name;
     }
@@ -22,9 +22,9 @@ public sealed class Role : Entity
     #region Methods
 
     #region Static factory
-    internal static Role Create(int id, string name)
+    internal static UserRole Create(int id, string name)
     {
-        return new Role(id, name);
+        return new UserRole(id, name);
     }
     #endregion
 

Clinics.Backend/Domain/Entities/Identity/UserRoles/Roles.cs → Clinics.Backend/Domain/Entities/Identity/UserRoles/UsersRoles.cs

 namespace Domain.Entities.Identity.UserRoles;
 
-public static class Roles
+public static class UsersRoles
 {
     #region Constant values
     public static int Count => 3;
@@ -8,13 +8,18 @@ public static class Roles
     public const string DoctorName = "doctor";
     public const string ReceptionistName = "receptionist";
 
-    public static Role Admin => Role.Create(1, AdminName);
-    public static Role Doctor => Role.Create(2, DoctorName);
-    public static Role Receptionist => Role.Create(3, ReceptionistName);
+    private static readonly UserRole _admin = UserRole.Create(1, AdminName);
+    public static UserRole Admin => _admin;
 
-    public static List<Role> GetAll()
+    private static readonly UserRole _doctor = UserRole.Create(2, DoctorName);
+    public static UserRole Doctor => _doctor;
+
+    private static readonly UserRole _receptionist = UserRole.Create(3, ReceptionistName);
+    public static UserRole Receptionist => _receptionist;
+
+    public static List<UserRole> GetAll()
     {
-        List<Role> roles = new();
+        List<UserRole> roles = new();
         roles.Add(Admin);
         roles.Add(Doctor);
         roles.Add(Receptionist);

Clinics.Backend/Domain/Entities/Identity/Users/DoctorUser.cs

@@ -37,7 +37,7 @@ public sealed class DoctorUser : Entity
         if (doctorResult.IsFailure)
             return Result.Failure<DoctorUser>(doctorResult.Error);
 
-        Result<User> userResult = User.Create(username, hashedPassword, Roles.Doctor.Name);
+        Result<User> userResult = User.Create(username, hashedPassword, UsersRoles.Doctor.Name);
         if (userResult.IsFailure)
             return Result.Failure<DoctorUser>(userResult.Error);
 

Clinics.Backend/Domain/Entities/Identity/Users/ReceptionistUser.cs

@@ -37,7 +37,7 @@ public sealed class ReceptionistUser : Entity
         if (personalInfoResult.IsFailure)
             return Result.Failure<ReceptionistUser>(personalInfoResult.Error);
 
-        Result<User> userResult = User.Create(userName, hashedPassword, Roles.Receptionist.Name);
+        Result<User> userResult = User.Create(userName, hashedPassword, UsersRoles.Receptionist.Name);
         if (userResult.IsFailure)
             return Result.Failure<ReceptionistUser>(userResult.Error);
 

Clinics.Backend/Domain/Entities/Identity/Users/User.cs

@@ -12,7 +12,7 @@ public sealed class User : Entity
     {
     }
 
-    private User(int id, string userName, string hashedPassword, Role role) : base(id)
+    private User(int id, string userName, string hashedPassword, UserRole role) : base(id)
     {
         UserName = userName;
         HashedPassword = hashedPassword;
@@ -23,7 +23,7 @@ public sealed class User : Entity
     #region Properties
     public string UserName { get; private set; } = null!;
     public string HashedPassword { get; private set; } = null!;
-    public Role Role { get; private set; } = null!;
+    public UserRole Role { get; private set; } = null!;
     #endregion
 
     #region Methods
@@ -37,9 +37,9 @@ public sealed class User : Entity
         }
 
         #region Check role
-        Result<Role> selectedRole = Result.Failure<Role>(IdentityErrors.InvalidRole);
-        List<Role> roles = Roles.GetAll();
-        foreach (Role roleItem in roles)
+        Result<UserRole> selectedRole = Result.Failure<UserRole>(IdentityErrors.InvalidRole);
+        List<UserRole> roles = UsersRoles.GetAll();
+        foreach (UserRole roleItem in roles)
         {
             if (roleItem.Name == role)
                 selectedRole = roleItem;

Clinics.Backend/Domain/Entities/People/Doctors/Shared/DoctorStatusValues/DoctorStatuses.cs

@@ -9,38 +9,14 @@ public static class DoctorStatuses
 
     public static int Count => 3;
 
-    public static DoctorStatus Available
-    {
-        get
-        {
-            var result = DoctorStatus.Create("متاح", 1);
-            if (result.IsFailure)
-                throw new InvalidValuesDomainException<DoctorStatus>();
-            return result.Value;
-        }
-    }
+    private readonly static DoctorStatus _available = DoctorStatus.Create("متاح", 1).Value;
+    public static DoctorStatus Available => _available;
 
-    public static DoctorStatus Working
-    {
-        get
-        {
-            var result = DoctorStatus.Create("لديه مريض", 2);
-            if (result.IsFailure)
-                throw new InvalidValuesDomainException<DoctorStatus>();
-            return result.Value;
-        }
-    }
+    private readonly static DoctorStatus _working = DoctorStatus.Create("لديه مريض", 2).Value;
+    public static DoctorStatus Working => _working;
 
-    public static DoctorStatus Busy
-    {
-        get
-        {
-            var result = DoctorStatus.Create("مشغول", 3);
-            if (result.IsFailure)
-                throw new InvalidValuesDomainException<DoctorStatus>();
-            return result.Value;
-        }
-    }
+    private readonly static DoctorStatus _busy = DoctorStatus.Create("مشغول", 3).Value;
+    public static DoctorStatus Busy => _busy;
 
     #endregion
 }

Clinics.Backend/Domain/Entities/People/Employees/Relations/EmployeeFamilyMembers/FamilyRoleValues/FamilyRoles.cs

@@ -7,49 +7,19 @@ public static class FamilyRoles
     #region Constant id values
 
     public static int Count => 4;
-    public static FamilyRole Husband
-    {
-        get
-        {
-            var result = FamilyRole.Create("زوج", 1);
-            if (result.IsFailure)
-                throw new InvalidValuesDomainException<FamilyRole>();
-            return result.Value;
-        }
-    }
-
-    public static FamilyRole Wife
-    {
-        get
-        {
-            var result = FamilyRole.Create("زوجة", 2);
-            if (result.IsFailure)
-                throw new InvalidValuesDomainException<FamilyRole>();
-            return result.Value;
-        }
-    }
-
-    public static FamilyRole Son
-    {
-        get
-        {
-            var result = FamilyRole.Create("ابن", 3);
-            if (result.IsFailure)
-                throw new InvalidValuesDomainException<FamilyRole>();
-            return result.Value;
-        }
-    }
-
-    public static FamilyRole Daughter
-    {
-        get
-        {
-            var result = FamilyRole.Create("ابنة", 4);
-            if (result.IsFailure)
-                throw new InvalidValuesDomainException<FamilyRole>();
-            return result.Value;
-        }
-    }
+
+    public readonly static FamilyRole _husband = FamilyRole.Create("زوج", 1).Value;
+    public static FamilyRole Husband => _husband;
+
+    public readonly static FamilyRole _wife = FamilyRole.Create("زوجة", 2).Value;
+    public static FamilyRole Wife => _wife;
+
+    public readonly static FamilyRole _son = FamilyRole.Create("ابن", 3).Value;
+    public static FamilyRole Son => _son;
+
+    public readonly static FamilyRole _daughter = FamilyRole.Create("ابنة", 4).Value;
+    public static FamilyRole Daughter => _daughter;
+    
 
     #endregion
 }

Clinics.Backend/Persistence/Configurations/Identity/Roles/RoleConfiguration.cs

@@ -4,11 +4,11 @@ using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
 namespace Persistence.Configurations.Identity.Roles;
 
-public class RoleConfiguration : IEntityTypeConfiguration<Role>
+public class RoleConfiguration : IEntityTypeConfiguration<UserRole>
 {
-    public void Configure(EntityTypeBuilder<Role> builder)
+    public void Configure(EntityTypeBuilder<UserRole> builder)
     {
-        builder.ToTable(nameof(Role));
+        builder.ToTable(nameof(UserRole));
 
         builder.Property(role => role.Id).ValueGeneratedNever();
 

Clinics.Backend/Persistence/Migrations/20240831184313_Update_User_Roles.Designer.cs

+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Persistence.Context;
+
+#nullable disable
+
+namespace Persistence.Migrations
+{
+    [DbContext(typeof(ClinicsDbContext))]
+    [Migration("20240831184313_Update_User_Roles")]
+    partial class Update_User_Roles
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.8")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("Domain.Entities.Identity.UserRoles.UserRole", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("UserRole", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.Identity.Users.DoctorUser", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("DoctorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DoctorId")
+                        .IsUnique();
+
+                    b.ToTable("DoctorUser", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.Identity.Users.ReceptionistUser", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("PersonalInfoId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PersonalInfoId")
+                        .IsUnique();
+
+                    b.ToTable("ReceptionistUser", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.Identity.Users.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("HashedPassword")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.HasIndex("UserName")
+                        .IsUnique();
+
+                    b.ToTable("User", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.Medicals.Diseases.Disease", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Disease", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.Medicals.Hospitals.Hospital", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Hospital", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.Medicals.MedicalImages.MedicalImage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(250)
+                        .HasColumnType("nvarchar(250)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MedicalImage", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.Medicals.MedicalTests.MedicalTest", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(250)
+                        .HasColumnType("nvarchar(250)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MedicalTest", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.Medicals.Medicines.Medicine", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Amount")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Dosage")
+                        .HasColumnType("numeric(9, 3)");
+
+                    b.Property<int>("MedicineFormId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MedicineFormId");
+
+                    b.ToTable("Medicine", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.Medicals.Medicines.MedicineFormValues.MedicineForm", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MedicineForm", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.People.Doctors.Doctor", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("PersonalInfoId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("StatusId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PersonalInfoId")
+                        .IsUnique();
+
+                    b.HasIndex("StatusId");
+
+                    b.ToTable("Doctor", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.People.Doctors.Shared.Constants.DoctorStatusValues.DoctorStatus", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("DoctorStatus", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.People.Doctors.Shared.DoctorPhone", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("DoctorId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("Phone")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("nvarchar(20)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DoctorId");
+
+                    b.HasIndex("Phone")
+                        .IsUnique();
+
+                    b.ToTable("DoctorPhone", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.People.Employees.Employee", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("AdditionalInfoId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CenterStatus")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<bool>("IsMarried")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("SerialNumber")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("nvarchar(20)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AdditionalInfoId")
+                        .IsUnique()
+                        .HasFilter("[AdditionalInfoId] IS NOT NULL");
+
+                    b.ToTable("Employee", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.People.Employees.Relations.EmployeeFamilyMembers.EmployeeFamilyMember", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("FamilyMemberId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RoleId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("FamilyMemberId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("EmployeeFamilyMember", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.People.Employees.Relations.EmployeeFamilyMembers.FamilyRoleValues.FamilyRole", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("FamilyRole", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.People.Employees.Shared.EmployeeAdditionalInfo", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AcademicQualification")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("ImageUrl")
+                        .HasMaxLength(150)
+                        .HasColumnType("nvarchar(150)");
+
+                    b.Property<string>("JobStatus")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("Location")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("Specialization")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<DateOnly?>("StartDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("WorkPhone")
+                        .HasMaxLength(20)
+                        .HasColumnType("nvarchar(20)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("EmployeeAdditionalInfo", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.People.FamilyMembers.FamilyMember", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("FamilyMember", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.People.Patients.Patient", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateOnly>("DateOfBirth")
+                        .HasColumnType("date");
+
+                    b.Property<int>("GenderId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PersonalInfoId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GenderId");
+
+                    b.HasIndex("PersonalInfoId")
+                        .IsUnique();
+
+                    b.ToTable("Patient", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.People.Patients.Relations.PatientDiseases.PatientDisease", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("DiseaseId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PatientId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DiseaseId");
+
+                    b.HasIndex("PatientId", "DiseaseId")
+                        .IsUnique();
+
+                    b.ToTable("PatientDisease", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.People.Patients.Relations.PatientMedicines.PatientMedicine", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("MedicineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Number")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PatientId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MedicineId");
+
+                    b.HasIndex("PatientId", "MedicineId")
+                        .IsUnique();
+
+                    b.ToTable("PatientMedicine", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.People.Shared.GenderValues.Gender", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Gender", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.People.Shared.PersonalInfo", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("MiddleName")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PersonalInfo", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.Visits.Holiday", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Duration")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("From")
+                        .HasColumnType("date");
+
+                    b.Property<int>("VisitId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("VisitId")
+                        .IsUnique();
+
+                    b.ToTable("Holiday", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.Visits.Relations.VisitMedicalImages.VisitMedicalImage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("MedicalImageId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Result")
+                        .HasMaxLength(250)
+                        .HasColumnType("nvarchar(250)");
+
+                    b.Property<int>("VisitId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MedicalImageId");
+
+                    b.HasIndex("VisitId", "MedicalImageId")
+                        .IsUnique();
+
+                    b.ToTable("VisitMedicalImage", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.Visits.Relations.VisitMedicalTests.VisitMedicalTest", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("MedicalTestId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Result")
+                        .HasMaxLength(250)
+                        .HasColumnType("nvarchar(250)");
+
+                    b.Property<int>("VisitId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MedicalTestId");
+
+                    b.HasIndex("VisitId", "MedicalTestId")
+                        .IsUnique();
+
+                    b.ToTable("VisitMedicalTest", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.Visits.Relations.VisitMedicines.VisitMedicine", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("MedicineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Number")
+                        .HasColumnType("int");
+
+                    b.Property<int>("VisitId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MedicineId");
+
+                    b.HasIndex("VisitId", "MedicineId")
+                        .IsUnique();
+
+                    b.ToTable("VisitMedicine", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.Visits.Visit", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateOnly>("Date")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Diagnosis")
+                        .IsRequired()
+                        .HasMaxLength(250)
+                        .HasColumnType("nvarchar(250)");
+
+                    b.Property<int>("DoctorId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("HospitalId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PatientId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DoctorId");
+
+                    b.HasIndex("HospitalId");
+
+                    b.HasIndex("PatientId");
+
+                    b.ToTable("Visit", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Entities.WaitingList.WaitingListRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("ArrivalTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("PatientId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PatientId");
+
+                    b.ToTable("WaitingListRecord", (string)null);
+                });
+
+            modelBuilder.Entity("EmployeeEmployee", b =>
+                {
+                    b.Property<int>("RelatedEmployeesId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RelatedToId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RelatedEmployeesId", "RelatedToId");
+
+                    b.HasIndex("RelatedToId");
+
+                    b.ToTable("EmployeeEmployee");
+                });
+
+            modelBuilder.Entity("Domain.Entities.Identity.Users.DoctorUser", b =>
+                {
+                    b.HasOne("Domain.Entities.People.Doctors.Doctor", "Doctor")
+                        .WithOne()
+                        .HasForeignKey("Domain.Entities.Identity.Users.DoctorUser", "DoctorId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Domain.Entities.Identity.Users.User", "User")
+                        .WithOne()
+                        .HasForeignKey("Domain.Entities.Identity.Users.DoctorUser", "Id")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Doctor");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Domain.Entities.Identity.Users.ReceptionistUser", b =>
+                {
+                    b.HasOne("Domain.Entities.Identity.Users.User", "User")
+                        .WithOne()
+                        .HasForeignKey("Domain.Entities.Identity.Users.ReceptionistUser", "Id")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Domain.Entities.People.Shared.PersonalInfo", "PersonalInfo")
+                        .WithOne()
+                        .HasForeignKey("Domain.Entities.Identity.Users.ReceptionistUser", "PersonalInfoId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("PersonalInfo");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Domain.Entities.Identity.Users.User", b =>
+                {
+                    b.HasOne("Domain.Entities.Identity.UserRoles.UserRole", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Role");
+                });
+
+            modelBuilder.Entity("Domain.Entities.Medicals.Medicines.Medicine", b =>
+                {
+                    b.HasOne("Domain.Entities.Medicals.Medicines.MedicineFormValues.MedicineForm", "MedicineForm")
+                        .WithMany()
+                        .HasForeignKey("MedicineFormId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("MedicineForm");
+                });
+
+            modelBuilder.Entity("Domain.Entities.People.Doctors.Doctor", b =>
+                {
+                    b.HasOne("Domain.Entities.People.Shared.PersonalInfo", "PersonalInfo")
+                        .WithOne()
+                        .HasForeignKey("Domain.Entities.People.Doctors.Doctor", "PersonalInfoId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Domain.Entities.People.Doctors.Shared.Constants.DoctorStatusValues.DoctorStatus", "Status")
+                        .WithMany()
+                        .HasForeignKey("StatusId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("PersonalInfo");
+
+                    b.Navigation("Status");
+                });
+
+            modelBuilder.Entity("Domain.Entities.People.Doctors.Shared.DoctorPhone", b =>
+                {
+                    b.HasOne("Domain.Entities.People.Doctors.Doctor", null)
+                        .WithMany("Phones")
+                        .HasForeignKey("DoctorId")
+                        .OnDelete(DeleteBehavior.NoAction);
+                });
+
+            modelBuilder.Entity("Domain.Entities.People.Employees.Employee", b =>
+                {
+                    b.HasOne("Domain.Entities.People.Employees.Shared.EmployeeAdditionalInfo", "AdditionalInfo")
+                        .WithOne()
+                        .HasForeignKey("Domain.Entities.People.Employees.Employee", "AdditionalInfoId")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.HasOne("Domain.Entities.People.Patients.Patient", "Patient")
+                        .WithOne()
+                        .HasForeignKey("Domain.Entities.People.Employees.Employee", "Id")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("AdditionalInfo");
+
+                    b.Navigation("Patient");
+                });
+
+            modelBuilder.Entity("Domain.Entities.People.Employees.Relations.EmployeeFamilyMembers.EmployeeFamilyMember", b =>
+                {
+                    b.HasOne("Domain.Entities.People.Employees.Employee", "Employee")
+                        .WithMany("FamilyMembers")
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Domain.Entities.People.FamilyMembers.FamilyMember", "FamilyMember")
+                        .WithMany()
+                        .HasForeignKey("FamilyMemberId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Domain.Entities.People.Employees.Relations.EmployeeFamilyMembers.FamilyRoleValues.FamilyRole", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("FamilyMember");
+
+                    b.Navigation("Role");
+                });
+
+            modelBuilder.Entity("Domain.Entities.People.FamilyMembers.FamilyMember", b =>
+                {
+                    b.HasOne("Domain.Entities.People.Patients.Patient", "Patient")
+                        .WithOne()
+                        .HasForeignKey("Domain.Entities.People.FamilyMembers.FamilyMember", "Id")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Patient");
+                });
+
+            modelBuilder.Entity("Domain.Entities.People.Patients.Patient", b =>
+                {
+                    b.HasOne("Domain.Entities.People.Shared.GenderValues.Gender", "Gender")
+                        .WithMany()
+                        .HasForeignKey("GenderId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Domain.Entities.People.Shared.PersonalInfo", "PersonalInfo")
+                        .WithOne()
+                        .HasForeignKey("Domain.Entities.People.Patients.Patient", "PersonalInfoId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Gender");
+
+                    b.Navigation("PersonalInfo");
+                });
+
+            modelBuilder.Entity("Domain.Entities.People.Patients.Relations.PatientDiseases.PatientDisease", b =>
+                {
+                    b.HasOne("Domain.Entities.Medicals.Diseases.Disease", "Disease")
+                        .WithMany("Patients")
+                        .HasForeignKey("DiseaseId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Domain.Entities.People.Patients.Patient", "Patient")
+                        .WithMany("Diseases")
+                        .HasForeignKey("PatientId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Disease");
+
+                    b.Navigation("Patient");
+                });
+
+            modelBuilder.Entity("Domain.Entities.People.Patients.Relations.PatientMedicines.PatientMedicine", b =>
+                {
+                    b.HasOne("Domain.Entities.Medicals.Medicines.Medicine", "Medicine")
+                        .WithMany("Patients")
+                        .HasForeignKey("MedicineId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Domain.Entities.People.Patients.Patient", "Patient")
+                        .WithMany("Medicines")
+                        .HasForeignKey("PatientId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Medicine");
+
+                    b.Navigation("Patient");
+                });
+
+            modelBuilder.Entity("Domain.Entities.Visits.Holiday", b =>
+                {
+                    b.HasOne("Domain.Entities.Visits.Visit", null)
+                        .WithOne("Holiday")
+                        .HasForeignKey("Domain.Entities.Visits.Holiday", "VisitId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Domain.Entities.Visits.Relations.VisitMedicalImages.VisitMedicalImage", b =>
+                {
+                    b.HasOne("Domain.Entities.Medicals.MedicalImages.MedicalImage", "MedicalImage")
+                        .WithMany()
+                        .HasForeignKey("MedicalImageId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Domain.Entities.Visits.Visit", "Visit")
+                        .WithMany("MedicalImages")
+                        .HasForeignKey("VisitId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("MedicalImage");
+
+                    b.Navigation("Visit");
+                });
+
+            modelBuilder.Entity("Domain.Entities.Visits.Relations.VisitMedicalTests.VisitMedicalTest", b =>
+                {
+                    b.HasOne("Domain.Entities.Medicals.MedicalTests.MedicalTest", "MedicalTest")
+                        .WithMany()
+                        .HasForeignKey("MedicalTestId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Domain.Entities.Visits.Visit", "Visit")
+                        .WithMany("MedicalTests")
+                        .HasForeignKey("VisitId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("MedicalTest");
+
+                    b.Navigation("Visit");
+                });
+
+            modelBuilder.Entity("Domain.Entities.Visits.Relations.VisitMedicines.VisitMedicine", b =>
+                {
+                    b.HasOne("Domain.Entities.Medicals.Medicines.Medicine", "Medicine")
+                        .WithMany()
+                        .HasForeignKey("MedicineId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Domain.Entities.Visits.Visit", "Visit")
+                        .WithMany("Medicines")
+                        .HasForeignKey("VisitId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Medicine");
+
+                    b.Navigation("Visit");
+                });
+
+            modelBuilder.Entity("Domain.Entities.Visits.Visit", b =>
+                {
+                    b.HasOne("Domain.Entities.People.Doctors.Doctor", "Doctor")
+                        .WithMany()
+                        .HasForeignKey("DoctorId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Domain.Entities.Medicals.Hospitals.Hospital", "Hospital")
+                        .WithMany()
+                        .HasForeignKey("HospitalId")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.HasOne("Domain.Entities.People.Patients.Patient", "Patient")
+                        .WithMany("Visits")
+                        .HasForeignKey("PatientId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Doctor");
+
+                    b.Navigation("Hospital");
+
+                    b.Navigation("Patient");
+                });
+
+            modelBuilder.Entity("Domain.Entities.WaitingList.WaitingListRecord", b =>
+                {
+                    b.HasOne("Domain.Entities.People.Patients.Patient", "Patient")
+                        .WithMany()
+                        .HasForeignKey("PatientId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Patient");
+                });
+
+            modelBuilder.Entity("EmployeeEmployee", b =>
+                {
+                    b.HasOne("Domain.Entities.People.Employees.Employee", null)
+                        .WithMany()
+                        .HasForeignKey("RelatedEmployeesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Domain.Entities.People.Employees.Employee", null)
+                        .WithMany()
+                        .HasForeignKey("RelatedToId")
+                        .OnDelete(DeleteBehavior.ClientCascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Domain.Entities.Medicals.Diseases.Disease", b =>
+                {
+                    b.Navigation("Patients");
+                });
+
+            modelBuilder.Entity("Domain.Entities.Medicals.Medicines.Medicine", b =>
+                {
+                    b.Navigation("Patients");
+                });
+
+            modelBuilder.Entity("Domain.Entities.People.Doctors.Doctor", b =>
+                {
+                    b.Navigation("Phones");
+                });
+
+            modelBuilder.Entity("Domain.Entities.People.Employees.Employee", b =>
+                {
+                    b.Navigation("FamilyMembers");
+                });
+
+            modelBuilder.Entity("Domain.Entities.People.Patients.Patient", b =>
+                {
+                    b.Navigation("Diseases");
+
+                    b.Navigation("Medicines");
+
+                    b.Navigation("Visits");
+                });
+
+            modelBuilder.Entity("Domain.Entities.Visits.Visit", b =>
+                {
+                    b.Navigation("Holiday");
+
+                    b.Navigation("MedicalImages");
+
+                    b.Navigation("MedicalTests");
+
+                    b.Navigation("Medicines");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Clinics.Backend/Persistence/Migrations/20240831184313_Update_User_Roles.cs

+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Persistence.Migrations
+{
+    /// <inheritdoc />
+    public partial class Update_User_Roles : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_User_Role_RoleId",
+                table: "User");
+
+            migrationBuilder.DropTable(
+                name: "Role");
+
+            migrationBuilder.CreateTable(
+                name: "UserRole",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false),
+                    Name = table.Column<string>(type: "nvarchar(50)", maxLength: 50, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_UserRole", x => x.Id);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_UserRole_Name",
+                table: "UserRole",
+                column: "Name",
+                unique: true);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_User_UserRole_RoleId",
+                table: "User",
+                column: "RoleId",
+                principalTable: "UserRole",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_User_UserRole_RoleId",
+                table: "User");
+
+            migrationBuilder.DropTable(
+                name: "UserRole");
+
+            migrationBuilder.CreateTable(
+                name: "Role",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false),
+                    Name = table.Column<string>(type: "nvarchar(50)", maxLength: 50, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Role", x => x.Id);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Role_Name",
+                table: "Role",
+                column: "Name",
+                unique: true);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_User_Role_RoleId",
+                table: "User",
+                column: "RoleId",
+                principalTable: "Role",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+    }
+}

Clinics.Backend/Persistence/Migrations/ClinicsDbContextModelSnapshot.cs

@@ -22,7 +22,7 @@ namespace Persistence.Migrations
 
             SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
 
-            modelBuilder.Entity("Domain.Entities.Identity.UserRoles.Role", b =>
+            modelBuilder.Entity("Domain.Entities.Identity.UserRoles.UserRole", b =>
                 {
                     b.Property<int>("Id")
                         .HasColumnType("int");
@@ -37,7 +37,7 @@ namespace Persistence.Migrations
                     b.HasIndex("Name")
                         .IsUnique();
 
-                    b.ToTable("Role", (string)null);
+                    b.ToTable("UserRole", (string)null);
                 });
 
             modelBuilder.Entity("Domain.Entities.Identity.Users.DoctorUser", b =>
@@ -763,7 +763,7 @@ namespace Persistence.Migrations
 
             modelBuilder.Entity("Domain.Entities.Identity.Users.User", b =>
                 {
-                    b.HasOne("Domain.Entities.Identity.UserRoles.Role", "Role")
+                    b.HasOne("Domain.Entities.Identity.UserRoles.UserRole", "Role")
                         .WithMany()
                         .HasForeignKey("RoleId")
                         .OnDelete(DeleteBehavior.Cascade)

Clinics.Backend/Persistence/SeedDatabase/AdminUser/SeedAdminUser.cs

-
-using Domain.Entities.Identity.UserRoles;
-using Domain.Entities.Identity.Users;
-using Domain.Exceptions.InvalidValue;
-using Domain.Shared;
-using Microsoft.EntityFrameworkCore;
-using Persistence.Context;
-using Persistence.Identity.PasswordsHashing;
-
-namespace Persistence.SeedDatabase.AdminUser;
-
-public class SeedAdminUser : ISeedAdminUser
-{
-    #region CTOR DI
-    private readonly ClinicsDbContext _context;
-    private readonly IPasswordHasher _passwordHasher;
-
-    public SeedAdminUser(ClinicsDbContext context, IPasswordHasher passwordHasher)
-    {
-        _context = context;
-        _passwordHasher = passwordHasher;
-    }
-    #endregion
-    public async Task Seed()
-    {
-        DbSet<User> users = _context.Set<User>();
-
-        Result<User> adminUserResult = User.Create(
-            "admin",
-            _passwordHasher.Hash("123"),
-            Roles.Admin.Name
-            );
-        if (adminUserResult.IsFailure)
-            throw new Exception("Unable to seed admin user");
-
-        if (users.Include(user => user.Role).Where(user => user.Role ==  Roles.Admin).ToList().Count != 1)
-        {
-            var adminUser = adminUserResult.Value;
-            _context.Entry(adminUser.Role).State = EntityState.Unchanged;
-            users.Add(adminUserResult.Value);
-            await _context.SaveChangesAsync();
-        }
-    }
-}

Clinics.Backend/Persistence/SeedDatabase/UserRoles.cs

@@ -4,7 +4,7 @@ using Persistence.Context;
 
 namespace Persistence.SeedDatabase;
 
-public class UserRoles : ISeed<Role>
+public class UserRoles : ISeed<UserRole>
 {
     #region CTOR DI
     private readonly ClinicsDbContext _context;
@@ -16,19 +16,19 @@ public class UserRoles : ISeed<Role>
     #endregion
     public async Task Seed()
     {
-        DbSet<Role> roles = _context.Set<Role>();
+        DbSet<UserRole> roles = _context.Set<UserRole>();
 
         var current = await roles.ToListAsync();
         // TODO: perform deep check on all seed operations
-        if (current.Count != Roles.Count)
+        if (current.Count != UsersRoles.Count)
         {
             roles.RemoveRange(current);
 
-            roles.Add(Roles.Admin);
+            roles.Add(UsersRoles.Admin);
 
-            roles.Add(Roles.Doctor);
+            roles.Add(UsersRoles.Doctor);
 
-            roles.Add(Roles.Receptionist);
+            roles.Add(UsersRoles.Receptionist);
 
             await _context.SaveChangesAsync();
         }

Clinics.Backend/Persistence/SeedDatabase/AdminUser/ISeedAdminUser.cs → Clinics.Backend/Persistence/SeedDatabase/Users/ISeedUsers.cs

 namespace Persistence.SeedDatabase.AdminUser;
 
-public interface ISeedAdminUser
+public interface ISeedUsers
 {
     public Task Seed();
 }

Clinics.Backend/Persistence/SeedDatabase/Users/SeedUsers.cs

+
+using Domain.Entities.Identity.UserRoles;
+using Domain.Entities.Identity.Users;
+using Domain.Shared;
+using Microsoft.EntityFrameworkCore;
+using Persistence.Context;
+using Persistence.Identity.PasswordsHashing;
+
+namespace Persistence.SeedDatabase.AdminUser;
+
+public class SeedUsers : ISeedUsers
+{
+    #region CTOR DI
+    private readonly ClinicsDbContext _context;
+    private readonly IPasswordHasher _passwordHasher;
+
+    public SeedUsers(ClinicsDbContext context, IPasswordHasher passwordHasher)
+    {
+        _context = context;
+        _passwordHasher = passwordHasher;
+    }
+    #endregion
+    public async Task Seed()
+    {
+
+        var currentCount = _context.Set<User>().ToList().Count;
+        if (currentCount == 0)
+        {
+            #region Seed admin
+            Result<User> adminUserResult = User.Create(
+                "admin",
+                _passwordHasher.Hash("123"),
+                UsersRoles.Admin.Name
+                );
+            if (adminUserResult.IsFailure)
+                throw new Exception("Unable to seed admin user");
+
+            var adminUser = adminUserResult.Value;
+            _context.Entry(adminUser.Role).State = EntityState.Unchanged;
+            _context.Set<User>().Add(adminUserResult.Value);
+
+            #endregion
+
+            #region Seed doctor
+            var doctorUserCreateResult = DoctorUser.Create(
+                "doctor",
+                _passwordHasher.Hash("123"),
+                "محمد",
+                "صالح",
+                "التركي"
+                );
+            if (doctorUserCreateResult.IsFailure)
+                throw new Exception("Unable to seed doctor user");
+            var doctorUser = doctorUserCreateResult.Value;
+            _context.Entry(doctorUser.User.Role).State = EntityState.Unchanged;
+            _context.Entry(doctorUser.Doctor.Status).State = EntityState.Unchanged;
+            _context.Set<DoctorUser>().Add(doctorUser);
+
+            #endregion
+
+            #region Seed receptionist
+            var receptionistUserCreateResult = ReceptionistUser.Create(
+                "receptionist",
+                _passwordHasher.Hash("123"),
+                "موفق",
+                "سامي",
+                "الحسين"
+                );
+            if (receptionistUserCreateResult.IsFailure)
+                throw new Exception("Unable to seed receptionist user");
+            var receptionistUser = receptionistUserCreateResult.Value;
+            _context.Entry(receptionistUser.User.Role).State = EntityState.Unchanged;
+            _context.Set<ReceptionistUser>().Add(receptionistUser);
+
+            #endregion
+
+            await _context.SaveChangesAsync();
+        }
+
+
+    }
+}