(B) Add identity classes, link them to DB

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

+using Domain.Primitives;
+
+namespace Domain.Entities.Identity.UserRoles;
+
+public sealed class Role : Entity
+{
+    #region Private ctor
+    private Role(int id) : base(id)
+    {
+    }
+
+    private Role(int id, string name) : base(id)
+    {
+        Name = name;
+    }
+    #endregion
+
+    #region Properties
+    public string Name { get; private set; } = null!;
+    #endregion
+
+    #region Methods
+
+    #region Static factory
+    internal static Role Create(int id, string name)
+    {
+        return new Role(id, name);
+    }
+    #endregion
+
+    #endregion
+}

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

+namespace Domain.Entities.Identity.UserRoles;
+
+public static class Roles
+{
+    #region Constant values
+    public static int Count => 3;
+    public static Role Admin => Role.Create(1, "admin");
+    public static Role Doctor => Role.Create(2, "doctor");
+    public static Role Receptionist => Role.Create(3, "receptionist");
+
+    public static List<Role> GetAll()
+    {
+        List<Role> roles = new();
+        roles.Add(Admin);
+        roles.Add(Doctor);
+        roles.Add(Receptionist);
+        return roles;
+    }
+    #endregion
+
+}

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

+using Domain.Entities.Identity.UserRoles;
+using Domain.Entities.People.Doctors;
+using Domain.Primitives;
+using Domain.Shared;
+
+namespace Domain.Entities.Identity.Users;
+
+public sealed class DoctorUser : Entity
+{
+    #region Private ctor
+    private DoctorUser(int id) : base(id)
+    {
+    }
+
+    private DoctorUser(int id, User user, Doctor doctor) : base(id)
+    {
+        User = user;
+        Doctor = doctor;
+    }
+    #endregion
+
+    #region Properties
+    public User User { get; private set; } = null!;
+    public Doctor Doctor { get; private set; } = null!;
+    #endregion
+
+    #region Methods
+
+    #region Static factory
+    public static Result<DoctorUser> Create (
+        string username, string hashedPassword, // User details
+
+        string firstName, string middleName, string lastName // Doctor details
+        )
+    {
+        Result<Doctor> doctorResult = Doctor.Create(firstName, middleName, lastName);
+        if (doctorResult.IsFailure)
+            return Result.Failure<DoctorUser>(doctorResult.Error);
+
+        Result<User> userResult = User.Create(username, hashedPassword, Roles.Doctor.Name);
+        if (userResult.IsFailure)
+            return Result.Failure<DoctorUser>(userResult.Error);
+
+        return new DoctorUser(0, userResult.Value, doctorResult.Value);
+    }
+    #endregion
+
+    #endregion
+}

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

+using Domain.Entities.Identity.UserRoles;
+using Domain.Entities.People.Shared;
+using Domain.Primitives;
+using Domain.Shared;
+
+namespace Domain.Entities.Identity.Users;
+
+public sealed class ReceptionistUser : Entity
+{
+    #region Private ctor
+    private ReceptionistUser(int id) : base(id)
+    {
+    }
+
+    private ReceptionistUser(int id, User user, PersonalInfo personalInfo) : base(id)
+    {
+        User = user;
+        PersonalInfo = personalInfo;
+    }
+    #endregion
+
+    #region Properties
+    public User User { get; private set; } = null!;
+    public PersonalInfo PersonalInfo { get; private set; } = null!;
+    #endregion
+
+    #region Methods
+
+    #region Static factory
+    public static Result<ReceptionistUser> Create(
+        string userName, string hashedPassword,
+
+        string firstName, string middleName, string lastName
+        )
+    {
+        Result<PersonalInfo> personalInfoResult = PersonalInfo.Create(firstName, middleName, lastName);
+        if (personalInfoResult.IsFailure)
+            return Result.Failure<ReceptionistUser>(personalInfoResult.Error);
+
+        Result<User> userResult = User.Create(userName, hashedPassword, Roles.Receptionist.Name);
+        if (userResult.IsFailure)
+            return Result.Failure<ReceptionistUser>(userResult.Error);
+
+        return new ReceptionistUser(0, userResult.Value, personalInfoResult.Value);
+
+    }
+    #endregion
+
+    #endregion
+}

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

+using Domain.Entities.Identity.UserRoles;
+using Domain.Errors;
+using Domain.Primitives;
+using Domain.Shared;
+
+namespace Domain.Entities.Identity.Users;
+
+public sealed class User : Entity
+{
+    #region Private ctor
+    private User(int id) : base(id)
+    {
+    }
+
+    private User(int id, string userName, string hashedPassword, Role role) : base(id)
+    {
+        UserName = userName;
+        HashedPassword = hashedPassword;
+        Role = role;
+    }
+    #endregion
+
+    #region Properties
+    public string UserName { get; private set; } = null!;
+    public string HashedPassword { get; private set; } = null!;
+    public Role Role { get; private set; } = null!;
+    #endregion
+
+    #region Methods
+    public static Result<User> Create(string userName, string hashedPassword, string role)
+    {
+        if (userName is null || hashedPassword is null || role is null)
+        {
+            return Result.Failure<User>(DomainErrors.InvalidValuesError);
+        }
+
+        #region Check role
+        Result<Role> selectedRole = Result.Failure<Role>(IdentityErrors.InvalidRole);
+        List<Role> roles = Roles.GetAll();
+        foreach (Role roleItem in roles)
+        {
+            if (roleItem.Name == role)
+                selectedRole = roleItem;
+        }
+        if (selectedRole.IsFailure)
+            return Result.Failure<User>(selectedRole.Error);
+        #endregion
+
+        return new User(0, userName, hashedPassword, selectedRole.Value);
+    }
+    #endregion
+}

Clinics.Backend/Domain/Errors/IdentityErrors.cs

+using Domain.Shared;
+
+namespace Domain.Errors;
+
+public static class IdentityErrors
+{
+    public static Error InvalidRole => new("Identity.InvalidRole", "Role specified for user is invalid");
+}

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

+using Domain.Entities.Identity.UserRoles;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Persistence.Configurations.Identity.Roles;
+
+public class RoleConfiguration : IEntityTypeConfiguration<Role>
+{
+    public void Configure(EntityTypeBuilder<Role> builder)
+    {
+        builder.ToTable(nameof(Role));
+
+        builder.Property(role => role.Name)
+            .HasMaxLength(50);
+
+        builder.HasIndex(role => role.Name)
+            .IsUnique();
+    }
+}

Clinics.Backend/Persistence/Configurations/Identity/Users/DoctorUserConfiguration.cs

+using Domain.Entities.Identity.Users;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Persistence.Configurations.Identity.Users;
+
+public class DoctorUserConfiguration : IEntityTypeConfiguration<DoctorUser>
+{
+    public void Configure(EntityTypeBuilder<DoctorUser> builder)
+    {
+        builder.ToTable(nameof(DoctorUser));
+
+        builder.Property(doctorUser => doctorUser.Id).ValueGeneratedOnAdd();
+
+        builder.HasOne(doctorUser => doctorUser.User)
+            .WithOne()
+            .HasForeignKey<DoctorUser>(doctorUser => doctorUser.Id)
+            .OnDelete(DeleteBehavior.NoAction);
+
+        builder.HasOne(doctorUser => doctorUser.Doctor)
+            .WithOne()
+            .HasForeignKey<DoctorUser>("DoctorId")
+            .OnDelete(DeleteBehavior.NoAction);
+    }
+}

Clinics.Backend/Persistence/Configurations/Identity/Users/ReceptionistUserConfiguration.cs

+using Domain.Entities.Identity.Users;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Persistence.Configurations.Identity.Users;
+
+public class ReceptionistUserConfiguration : IEntityTypeConfiguration<ReceptionistUser>
+{
+    public void Configure(EntityTypeBuilder<ReceptionistUser> builder)
+    {
+        builder.ToTable(nameof(ReceptionistUser));
+
+        builder.Property(receptionistUser => receptionistUser.Id).ValueGeneratedOnAdd();
+
+        builder.HasOne(receptionistUser => receptionistUser.User)
+            .WithOne()
+            .HasForeignKey<ReceptionistUser>(receptionistUser => receptionistUser.Id)
+            .OnDelete(DeleteBehavior.NoAction);
+
+        builder.HasOne(receptionistUser => receptionistUser.PersonalInfo)
+            .WithOne()
+            .HasForeignKey<ReceptionistUser>("PersonalInfoId")
+            .OnDelete(DeleteBehavior.NoAction);
+    }
+}

Clinics.Backend/Persistence/Configurations/Identity/Users/UserConfiguration.cs

+using Domain.Entities.Identity.Users;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Persistence.Configurations.Identity.Users;
+
+public class UserConfiguration : IEntityTypeConfiguration<User>
+{
+    public void Configure(EntityTypeBuilder<User> builder)
+    {
+        builder.ToTable(nameof(User));
+
+        builder.HasIndex(user => user.UserName)
+            .IsUnique();
+
+        builder.HasOne(user => user.Role)
+            .WithMany()
+            .HasForeignKey("RoleId");
+    }
+}

Clinics.Backend/Persistence/Migrations/20240820202107_Add_Identity.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("20240820202107_Add_Identity")]
+    partial class Add_Identity
+    {
+        /// <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.Role", 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.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("Role", (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.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<int?>("DoctorId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsServed")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(false);
+
+                    b.Property<int>("PatientId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DoctorId");
+
+                    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.Role", "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.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.Doctors.Doctor", "Doctor")
+                        .WithMany()
+                        .HasForeignKey("DoctorId")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.HasOne("Domain.Entities.People.Patients.Patient", "Patient")
+                        .WithMany()
+                        .HasForeignKey("PatientId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Doctor");
+
+                    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("MedicalImages");
+
+                    b.Navigation("MedicalTests");
+
+                    b.Navigation("Medicines");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Clinics.Backend/Persistence/Migrations/20240820202107_Add_Identity.cs

+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Persistence.Migrations
+{
+    /// <inheritdoc />
+    public partial class Add_Identity : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "Role",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    Name = table.Column<string>(type: "nvarchar(50)", maxLength: 50, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Role", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "User",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    UserName = table.Column<string>(type: "nvarchar(450)", nullable: false),
+                    HashedPassword = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    RoleId = table.Column<int>(type: "int", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_User", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_User_Role_RoleId",
+                        column: x => x.RoleId,
+                        principalTable: "Role",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "DoctorUser",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false),
+                    DoctorId = table.Column<int>(type: "int", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_DoctorUser", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_DoctorUser_Doctor_DoctorId",
+                        column: x => x.DoctorId,
+                        principalTable: "Doctor",
+                        principalColumn: "Id");
+                    table.ForeignKey(
+                        name: "FK_DoctorUser_User_Id",
+                        column: x => x.Id,
+                        principalTable: "User",
+                        principalColumn: "Id");
+                });
+
+            migrationBuilder.CreateTable(
+                name: "ReceptionistUser",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false),
+                    PersonalInfoId = table.Column<int>(type: "int", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_ReceptionistUser", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_ReceptionistUser_PersonalInfo_PersonalInfoId",
+                        column: x => x.PersonalInfoId,
+                        principalTable: "PersonalInfo",
+                        principalColumn: "Id");
+                    table.ForeignKey(
+                        name: "FK_ReceptionistUser_User_Id",
+                        column: x => x.Id,
+                        principalTable: "User",
+                        principalColumn: "Id");
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_DoctorUser_DoctorId",
+                table: "DoctorUser",
+                column: "DoctorId",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ReceptionistUser_PersonalInfoId",
+                table: "ReceptionistUser",
+                column: "PersonalInfoId",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Role_Name",
+                table: "Role",
+                column: "Name",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_User_RoleId",
+                table: "User",
+                column: "RoleId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_User_UserName",
+                table: "User",
+                column: "UserName",
+                unique: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "DoctorUser");
+
+            migrationBuilder.DropTable(
+                name: "ReceptionistUser");
+
+            migrationBuilder.DropTable(
+                name: "User");
+
+            migrationBuilder.DropTable(
+                name: "Role");
+        }
+    }
+}

Clinics.Backend/Persistence/Migrations/ClinicsDbContextModelSnapshot.cs

@@ -22,6 +22,90 @@ namespace Persistence.Migrations
 
             SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
 
+            modelBuilder.Entity("Domain.Entities.Identity.UserRoles.Role", 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.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("Role", (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")
@@ -624,6 +708,55 @@ namespace Persistence.Migrations
                     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.Role", "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")