fix s .

PSManagement.Api/Controllers/Authentication/AuthenticationController.cs

-using FluentResults;
+
+using FluentResults;
 using Microsoft.AspNetCore.Mvc;
 using PSManagement.Application.Contracts.Authentication;
 using PSManagement.Contracts.Authentication;
@@ -32,7 +33,7 @@ namespace PSManagement.Api.Controllers.Authentication
                 return Ok(response);
             }
 
-            return Problem(title: result.Errors[0].Message,detail:result.Errors[0].Reasons[0].Message,statusCode:400);
+            return Problem(title: result.Errors[0].Message,detail:result.Errors[0].Reasons[0]?.Message,statusCode:401);
         }
         [HttpPost("Register")]
         public async Task<IActionResult> Register([FromBody]  RegisterRequest registerRequest)
@@ -55,7 +56,7 @@ namespace PSManagement.Api.Controllers.Authentication
                 return Ok(response);
             }
 
-            return Problem(title: "An Errorr Occured "+result.Errors[0].Message , detail: result.Reasons[0].Message, statusCode: 400);
+            return Problem(title: "An Errorr Occured " , detail:"", statusCode: 400);
         }
 
     }

PSManagement.Api/Controllers/Customers/CustomersController.cs

@@ -13,12 +13,16 @@ using AutoMapper;
 using PSManagement.Application.Customers.UseCases.Commands.AddContactInfo;
 using PSManagement.Application.Customers.UseCases.Commands.DeleteCustomer;
 using PSManagement.Application.Customers.UseCases.Commands.UpdateCustomer;
+using PSManagement.Application.Customers.UseCases.Queries.ListAllCustomers;
+using PSManagement.Contracts.Customers.Responses;
+using FluentResults;
+using PSManagement.Application.Customers.UseCases.Queries.GetCustomer;
 
 namespace PSManagement.Api.Controllers.Customers
 {
     [Route("api/[controller]")]
     [ApiController]
-    [Authorize]
+  //  [Authorize]
     public class CustomersController : ControllerBase
     {
         private readonly IMediator _sender;
@@ -30,6 +34,25 @@ namespace PSManagement.Api.Controllers.Customers
             _mapper = mapper;
         }
 
+        [HttpGet]
+        public async Task<IActionResult> ListCustomers()
+        {
+            var query = new ListAllCustomersQuery();
+
+            var result = _mapper.Map<Result<IEnumerable<CustomerRecord>>>( await _sender.Send(query));
+         
+            return Ok(result);
+        }
+
+        [HttpGet("{id}")]
+        public async Task<IActionResult> GetCustomer(int id )
+        {
+            var query = new GetCustomerQuery(id);
+
+            var result = _mapper.Map<Result<CustomerRecord>>(await _sender.Send(query));
+
+            return Ok(result);
+        }
         [HttpPost]
         public async Task<IActionResult> CreateCustomer(CreateCustomerRequest request)
         {
@@ -50,9 +73,12 @@ namespace PSManagement.Api.Controllers.Customers
             return Ok(result);
 
         }
-        [HttpPut]
-        public async Task<IActionResult> UpdateCustomer(UpdateCustomerRequest request)
+        [HttpPut("{id}")]
+        public async Task<IActionResult> UpdateCustomer(int id ,UpdateCustomerRequest request)
         {
+            if(id != request.CustomerId){
+                return Problem();
+            }
             var command = _mapper.Map<UpdateCustomerCommand>(request);
 
             var result = await _sender.Send(command);

PSManagement.Api/DI/DependencyInjection.cs

@@ -21,7 +21,7 @@ namespace PSManagement.Api.DI
             services.AddApiCors();
 
             services.AddScoped<Mapper>();
-            services.AddAutoMapper(typeof(CustomerMapperConfiguration));
+            services.AddAutoMapper(typeof(CustomerMapperConfiguration),typeof(MapperConfigurations));
 
             return services;
         }

PSManagement.Api/Mappers/CustomerMapperConfiguration.cs

@@ -4,6 +4,8 @@ using PSManagement.Application.Customers.UseCases.Commands.AddContactInfo;
 using PSManagement.Application.Customers.UseCases.Commands.CreateCustomer;
 using PSManagement.Application.Customers.UseCases.Commands.UpdateCustomer;
 using PSManagement.Contracts.Customers.Requests;
+using PSManagement.Contracts.Customers.Responses;
+using PSManagement.SharedKernel.Utilities;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -20,7 +22,19 @@ namespace PSManagement.Api.Mappers
 
             CreateMap<AddContactInfoRequest, AddContactInfoCommand>().ReverseMap();
             CreateMap<AddressRecord, AddressDTO>().ReverseMap();
+//            CreateMap< IEnumerable<CustomerDTO>, ListCustomersResponse>().ma(src => src.Customers ,des => des.);
+            CreateMap<CustomerDTO, CustomerRecord>();
+            CreateMap<ContactInfoDTO, ContactInfoRecord>();
 
+            CreateMap<CustomerRecord, CustomerDTO>().ForMember(src =>src.ContactInfo , des => des.Ignore());
+            CreateMap<CustomerDTO, CustomerRecord>()
+            .ForMember(dest => dest.CustomerName, opt => opt.MapFrom(src => src.CustomerName))
+            .ForMember(dest => dest.Email, opt => opt.MapFrom(src => src.Email))
+            .ForMember(dest => dest.Address, opt => opt.MapFrom(src => src.Address));
+
+            CreateMap<IEnumerable<CustomerRecord>, ListCustomersResponse>()
+                    .ConstructUsing(src => new ListCustomersResponse(src));
+            
         }
     }
 }

PSManagement.Api/Mappers/MapperConfigurations.cs

+using AutoMapper;
+using FluentResults;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace PSManagement.Api.Mappers
+{
+    public class MapperConfigurations :Profile
+    {
+        public MapperConfigurations()
+        {
+            CreateMap(typeof(Result<>), typeof(Result<>)).ConvertUsing(typeof(ResultToResultConverter<,>));
+        }
+    }
+    public class ResultToResultConverter<TSource, TDestination> : ITypeConverter<Result<TSource>, Result<TDestination>>
+    {
+        public Result<TDestination> Convert(Result<TSource> source, Result<TDestination> destination, ResolutionContext context)
+        {
+            if (source.IsSuccess)
+            {
+                var mappedValue = context.Mapper.Map<TDestination>(source.Value);
+                return Result.Ok(mappedValue);
+            }
+            else
+            {
+                return Result.Fail<TDestination>(source.Errors);
+            }
+        }
+    }
+}

PSManagement.Api/PSManagement.Api.csproj

@@ -7,7 +7,7 @@
   <ItemGroup>
     <PackageReference Include="AutoMapper" Version="7.0.1" />
     <PackageReference Include="AutoMapper.Extensions.Microsoft.DependencyInjection" Version="5.0.1" />
-    <PackageReference Include="MediatR" Version="5.1.0" />
+    <PackageReference Include="MediatR" Version="8.0.1" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="5.0.17">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

PSManagement.Contracts/Customers/Responses/ContactInfoRecord.cs

+using System;
+
+namespace PSManagement.Contracts.Customers.Responses
+{
+    public class ContactInfoRecord {
+        public String ContactType { get; set; }
+        public String ContactValue { get; set; }
+    }
+}

PSManagement.Contracts/Customers/Responses/CustomerRecord.cs

+using PSManagement.Contracts.Customers.Requests;
+using System;
+using System.Collections.Generic;
+
+namespace PSManagement.Contracts.Customers.Responses
+{
+    public class CustomerRecord {
+        public CustomerRecord()
+        {
+
+        }
+
+        public int Id { get; set; }
+        public String CustomerName { get; set; }
+        public String Email { get; set; }
+        public AddressRecord Address { get; set; }
+        public IEnumerable<ContactInfoRecord> ContactInfo { get; set; }
+    }
+}

PSManagement.Contracts/Customers/Responses/ListCustomersResponse.cs

+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PSManagement.Contracts.Customers.Responses
+{
+    public record  ListCustomersResponse( IEnumerable<CustomerRecord> Customers );
+    
+}

PSManagement.Contracts/PSManagement.Contracts.csproj

@@ -4,8 +4,4 @@
     <TargetFramework>net5.0</TargetFramework>
   </PropertyGroup>
 
-  <ItemGroup>
-    <Folder Include="Customers\Responses\" />
-  </ItemGroup>
-
 </Project>

PSManagement.Infrastructure.Persistence/AppDataContext/AppDbContext.cs

 using Microsoft.EntityFrameworkCore;
 using PSManagement.Domain.Customers.Aggregate;
+using PSManagement.Domain.Departments.Aggregate;
+using PSManagement.Domain.Employees.Aggregate;
 using PSManagement.Domain.Identity.Aggregate;
+using PSManagement.Domain.Projects.Aggregate;
+using PSManagement.Domain.Steps.Aggregate;
+using PSManagement.Domain.Steps.Entities;
+using PSManagement.Domain.Tracking;
+using PSManagement.Domain.Tracking.Entities;
 
 namespace PSManagement.Infrastructure.Persistence
 {
@@ -14,6 +21,19 @@ namespace PSManagement.Infrastructure.Persistence
 
         public DbSet<User> Users { get; set; }
         public DbSet<Customer> Customers { get; set; }
+        public DbSet<Employee> Employees { get; set; }
+        public DbSet<Department> Departments { get; set; }
+        public DbSet<Project> Projects { get; set; }
+        public DbSet<Step> Steps { get; set; }
+
+        public DbSet<Item> Items { get; set; }
+        public DbSet<Track> Tracks { get; set; }
+        public DbSet<EmployeeTrack> EmployeeTraks { get; set; }
+
+        public DbSet<StepTrack> StepTracks { get; set; }
+
+
+
 
         protected override void OnModelCreating(ModelBuilder modelBuilder)
 

PSManagement.Infrastructure.Persistence/EntitiesConfiguration/EmployeeEntityConfiguration.cs

+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using PSManagement.Domain.Employees.Aggregate;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PSManagement.Infrastructure.Persistence.EntitiesConfiguration
+{
+    public class EmployeeEntityConfiguration : IEntityTypeConfiguration<Employee>
+    {
+        public void Configure(EntityTypeBuilder<Employee> builder)
+        {
+
+            builder.OwnsOne(c => c.Availability, 
+                p => {
+                    p.Property(e => e.IsAvailable).HasColumnName("IsAvailable");
+                    p.Property(e => e.WorkingHours).HasColumnName("WorkingHours");
+                }
+            );
+            builder.OwnsOne(c => c.PersonalInfo,
+                    p => {
+                        p.Property(e => e.LastName).HasColumnName("LastName");
+                        p.Property(e => e.FirstName).HasColumnName("FirstName");
+                    }
+            );
+            
+        }
+    }
+}

PSManagement.Infrastructure.Persistence/EntitiesConfiguration/ItemEntityConfiguration.cs

+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using PSManagement.Domain.Steps.Entities;
+
+namespace PSManagement.Infrastructure.Persistence.EntitiesConfiguration
+{
+    public class ItemEntityConfiguration : IEntityTypeConfiguration<Item>
+    {
+        public void Configure(EntityTypeBuilder<Item> builder)
+        {
+
+            builder.OwnsOne(c => c.Price, 
+                p => {
+                    p.Property(e => e.Ammount).HasColumnName("Ammount");
+                    p.Property(e => e.Currency).HasColumnName("Currency");
+                }
+            );
+        }
+    }
+}

PSManagement.Infrastructure.Persistence/EntitiesConfiguration/ProjectEntityConfiguration.cs

+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using PSManagement.Domain.Projects.Aggregate;
+
+namespace PSManagement.Infrastructure.Persistence.EntitiesConfiguration
+{
+    public class ProjectEntityConfiguration : IEntityTypeConfiguration<Project>
+    {
+        public void Configure(EntityTypeBuilder<Project> builder)
+        {
+
+            builder.OwnsOne(c => c.ProjectAggreement,
+                p => { 
+                    p.Property(e => e.AggreementDate).HasColumnName("AggreementDate");
+                    p.Property(e => e.AggreementNumber).HasColumnName("AggreementNumber");
+                }
+            );
+            builder.OwnsOne(c => c.ProjectInfo,
+                p => {
+                    p.Property(e => e.Description).HasColumnName("Description");
+                    p.Property(e => e.Code).HasColumnName("Code");
+                    p.Property(e => e.Name).HasColumnName("Name");
+                    
+
+                }
+            );
+
+            builder.OwnsOne(c => c.ProposalInfo,
+                    p => {
+                        p.Property(e => e.ProposingBookDate).HasColumnName("ProposingBookDate");
+                        p.Property(e => e.ProposingBookNumber).HasColumnName("ProposingBookNumber");
+                    }
+            );
+
+        }
+    }
+}

PSManagement.Infrastructure.Persistence/EntitiesConfiguration/StepEntityConfiguration.cs

+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using PSManagement.Domain.Steps.Aggregate;
+
+namespace PSManagement.Infrastructure.Persistence.EntitiesConfiguration
+{
+    public class StepEntityConfiguration : IEntityTypeConfiguration<Step>
+    {
+        public void Configure(EntityTypeBuilder<Step> builder)
+        {
+
+            
+        }
+    }
+}

PSManagement.Infrastructure.Persistence/Migrations/20240731070622_addCustomer4.Designer.cs

+// <auto-generated />
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using PSManagement.Infrastructure.Persistence;
+
+namespace PSManagement.Infrastructure.Persistence.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20240731070622_addCustomer4")]
+    partial class addCustomer4
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("Relational:Collation", "Arabic_CI_AS")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128)
+                .HasAnnotation("ProductVersion", "5.0.17")
+                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+            modelBuilder.Entity("PSManagement.Domain.Customers.Aggregate.Customer", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("CustomerName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Customers");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Identity.Aggregate.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("HashedPassword")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Customers.Aggregate.Customer", b =>
+                {
+                    b.OwnsMany("PSManagement.Domain.Customers.Entities.ContactInfo", "ContactInfo", b1 =>
+                        {
+                            b1.Property<int>("CustomerId")
+                                .HasColumnType("int");
+
+                            b1.Property<int>("Id")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("ContactType")
+                                .HasColumnType("nvarchar(max)");
+
+                            b1.Property<string>("ContactValue")
+                                .HasColumnType("nvarchar(max)");
+
+                            b1.HasKey("CustomerId", "Id");
+
+                            b1.ToTable("ContactInfo");
+
+                            b1.WithOwner()
+                                .HasForeignKey("CustomerId");
+                        });
+
+                    b.OwnsOne("PSManagement.Domain.Customers.ValueObjects.Address", "Address", b1 =>
+                        {
+                            b1.Property<int>("CustomerId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("City")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("City");
+
+                            b1.Property<string>("StreetName")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("StreetName");
+
+                            b1.Property<int>("StreetNumber")
+                                .HasColumnType("int")
+                                .HasColumnName("StreetNumber");
+
+                            b1.Property<int>("ZipCode")
+                                .HasColumnType("int")
+                                .HasColumnName("ZipCode");
+
+                            b1.HasKey("CustomerId");
+
+                            b1.ToTable("Customers");
+
+                            b1.WithOwner()
+                                .HasForeignKey("CustomerId");
+                        });
+
+                    b.Navigation("Address");
+
+                    b.Navigation("ContactInfo");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

PSManagement.Infrastructure.Persistence/Migrations/20240731070622_addCustomer4.cs

+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace PSManagement.Infrastructure.Persistence.Migrations
+{
+    public partial class addCustomer4 : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.RenameColumn(
+                name: "ConatctValue",
+                table: "ContactInfo",
+                newName: "ContactValue");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.RenameColumn(
+                name: "ContactValue",
+                table: "ContactInfo",
+                newName: "ConatctValue");
+        }
+    }
+}

PSManagement.Infrastructure.Persistence/Migrations/20240801155515_AddDomains.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 PSManagement.Infrastructure.Persistence;
+
+namespace PSManagement.Infrastructure.Persistence.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20240801155515_AddDomains")]
+    partial class AddDomains
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("Relational:Collation", "Arabic_CI_AS")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128)
+                .HasAnnotation("ProductVersion", "5.0.17")
+                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+            modelBuilder.Entity("PSManagement.Domain.Customers.Aggregate.Customer", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("CustomerName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Customers");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Departments.Aggregate.Department", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Departments");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Employees.Aggregate.Employee", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int>("HIASTId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ProjectId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Employees");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Identity.Aggregate.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("HashedPassword")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Aggregate.Project", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int?>("ExecuterId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ProposerId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("TeamLeaderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ExecuterId");
+
+                    b.HasIndex("ProposerId");
+
+                    b.HasIndex("TeamLeaderId");
+
+                    b.ToTable("Projects");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Steps.Aggregate.Step", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Duration")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ProjectId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("StartDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("StepName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Steps");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Steps.Entities.Item", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("ItemDescription")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ItemName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("StepId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StepId");
+
+                    b.ToTable("Items");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Entities.EmployeeTrack", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int?>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("StepTrackId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkingHour")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("StepTrackId");
+
+                    b.ToTable("EmployeeTraks");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Entities.StepTrack", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int?>("StepId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("TrackId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StepId");
+
+                    b.HasIndex("TrackId");
+
+                    b.ToTable("StepTracks");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Track", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int?>("ProjectId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("TrackDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("TrackNote")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Tracks");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Customers.Aggregate.Customer", b =>
+                {
+                    b.OwnsMany("PSManagement.Domain.Customers.Entities.ContactInfo", "ContactInfo", b1 =>
+                        {
+                            b1.Property<int>("CustomerId")
+                                .HasColumnType("int");
+
+                            b1.Property<int>("Id")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("ContactType")
+                                .HasColumnType("nvarchar(max)");
+
+                            b1.Property<string>("ContactValue")
+                                .HasColumnType("nvarchar(max)");
+
+                            b1.HasKey("CustomerId", "Id");
+
+                            b1.ToTable("ContactInfo");
+
+                            b1.WithOwner()
+                                .HasForeignKey("CustomerId");
+                        });
+
+                    b.OwnsOne("PSManagement.Domain.Customers.ValueObjects.Address", "Address", b1 =>
+                        {
+                            b1.Property<int>("CustomerId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("City")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("City");
+
+                            b1.Property<string>("StreetName")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("StreetName");
+
+                            b1.Property<int>("StreetNumber")
+                                .HasColumnType("int")
+                                .HasColumnName("StreetNumber");
+
+                            b1.Property<int>("ZipCode")
+                                .HasColumnType("int")
+                                .HasColumnName("ZipCode");
+
+                            b1.HasKey("CustomerId");
+
+                            b1.ToTable("Customers");
+
+                            b1.WithOwner()
+                                .HasForeignKey("CustomerId");
+                        });
+
+                    b.Navigation("Address");
+
+                    b.Navigation("ContactInfo");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Employees.Aggregate.Employee", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Projects.Aggregate.Project", null)
+                        .WithMany("Participants")
+                        .HasForeignKey("ProjectId");
+
+                    b.OwnsOne("PSManagement.Domain.Employees.Aggregate.Availability", "Availability", b1 =>
+                        {
+                            b1.Property<int>("EmployeeId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<bool>("IsAvailable")
+                                .HasColumnType("bit")
+                                .HasColumnName("IsAvailable");
+
+                            b1.Property<int>("WorkingHours")
+                                .HasColumnType("int")
+                                .HasColumnName("WorkingHours");
+
+                            b1.HasKey("EmployeeId");
+
+                            b1.ToTable("Employees");
+
+                            b1.WithOwner()
+                                .HasForeignKey("EmployeeId");
+                        });
+
+                    b.OwnsOne("PSManagement.Domain.Employees.Aggregate.PersonalInfo", "PersonalInfo", b1 =>
+                        {
+                            b1.Property<int>("EmployeeId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("FirstName")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("FirstName");
+
+                            b1.Property<string>("LastName")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("LastName");
+
+                            b1.HasKey("EmployeeId");
+
+                            b1.ToTable("Employees");
+
+                            b1.WithOwner()
+                                .HasForeignKey("EmployeeId");
+                        });
+
+                    b.Navigation("Availability");
+
+                    b.Navigation("PersonalInfo");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Aggregate.Project", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Departments.Aggregate.Department", "Executer")
+                        .WithMany()
+                        .HasForeignKey("ExecuterId");
+
+                    b.HasOne("PSManagement.Domain.Employees.Aggregate.Employee", "Proposer")
+                        .WithMany()
+                        .HasForeignKey("ProposerId");
+
+                    b.HasOne("PSManagement.Domain.Employees.Aggregate.Employee", "TeamLeader")
+                        .WithMany()
+                        .HasForeignKey("TeamLeaderId");
+
+                    b.OwnsOne("PSManagement.Domain.Projects.Aggregate.Aggreement", "ProjectAggreement", b1 =>
+                        {
+                            b1.Property<int>("ProjectId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<DateTime>("AggreementDate")
+                                .HasColumnType("datetime2")
+                                .HasColumnName("AggreementDate");
+
+                            b1.Property<int>("AggreementNumber")
+                                .HasColumnType("int")
+                                .HasColumnName("AggreementNumber");
+
+                            b1.HasKey("ProjectId");
+
+                            b1.ToTable("Projects");
+
+                            b1.WithOwner()
+                                .HasForeignKey("ProjectId");
+                        });
+
+                    b.OwnsOne("PSManagement.Domain.Projects.Aggregate.ProjectInfo", "ProjectInfo", b1 =>
+                        {
+                            b1.Property<int>("ProjectId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("Code")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("Code");
+
+                            b1.Property<string>("Description")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("Description");
+
+                            b1.Property<string>("Name")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("Name");
+
+                            b1.HasKey("ProjectId");
+
+                            b1.ToTable("Projects");
+
+                            b1.WithOwner()
+                                .HasForeignKey("ProjectId");
+                        });
+
+                    b.OwnsOne("PSManagement.Domain.Projects.Aggregate.ProposalInfo", "ProposalInfo", b1 =>
+                        {
+                            b1.Property<int>("ProjectId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<DateTime>("ProposingBookDate")
+                                .HasColumnType("datetime2")
+                                .HasColumnName("ProposingBookDate");
+
+                            b1.Property<int>("ProposingBookNumber")
+                                .HasColumnType("int")
+                                .HasColumnName("ProposingBookNumber");
+
+                            b1.HasKey("ProjectId");
+
+                            b1.ToTable("Projects");
+
+                            b1.WithOwner()
+                                .HasForeignKey("ProjectId");
+                        });
+
+                    b.Navigation("Executer");
+
+                    b.Navigation("ProjectAggreement");
+
+                    b.Navigation("ProjectInfo");
+
+                    b.Navigation("ProposalInfo");
+
+                    b.Navigation("Proposer");
+
+                    b.Navigation("TeamLeader");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Steps.Aggregate.Step", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Projects.Aggregate.Project", null)
+                        .WithMany("Steps")
+                        .HasForeignKey("ProjectId");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Steps.Entities.Item", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Steps.Aggregate.Step", null)
+                        .WithMany("Purchases")
+                        .HasForeignKey("StepId");
+
+                    b.OwnsOne("PSManagement.SharedKernel.ValueObjects.Money", "Price", b1 =>
+                        {
+                            b1.Property<int>("ItemId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<int>("Ammount")
+                                .HasColumnType("int")
+                                .HasColumnName("Ammount");
+
+                            b1.Property<string>("Currency")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("Currency");
+
+                            b1.HasKey("ItemId");
+
+                            b1.ToTable("Items");
+
+                            b1.WithOwner()
+                                .HasForeignKey("ItemId");
+                        });
+
+                    b.Navigation("Price");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Entities.EmployeeTrack", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Employees.Aggregate.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId");
+
+                    b.HasOne("PSManagement.Domain.Tracking.Entities.StepTrack", null)
+                        .WithMany("EmployeeTracks")
+                        .HasForeignKey("StepTrackId");
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Entities.StepTrack", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Steps.Aggregate.Step", "Step")
+                        .WithMany()
+                        .HasForeignKey("StepId");
+
+                    b.HasOne("PSManagement.Domain.Tracking.Track", null)
+                        .WithMany("StepsTracks")
+                        .HasForeignKey("TrackId");
+
+                    b.Navigation("Step");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Track", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Projects.Aggregate.Project", "Project")
+                        .WithMany()
+                        .HasForeignKey("ProjectId");
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Aggregate.Project", b =>
+                {
+                    b.Navigation("Participants");
+
+                    b.Navigation("Steps");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Steps.Aggregate.Step", b =>
+                {
+                    b.Navigation("Purchases");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Entities.StepTrack", b =>
+                {
+                    b.Navigation("EmployeeTracks");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Track", b =>
+                {
+                    b.Navigation("StepsTracks");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

PSManagement.Infrastructure.Persistence/Migrations/20240801155515_AddDomains.cs

+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace PSManagement.Infrastructure.Persistence.Migrations
+{
+    public partial class AddDomains : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+           
+            migrationBuilder.CreateTable(
+                name: "Departments",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    Name = table.Column<string>(type: "nvarchar(max)", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Departments", x => x.Id);
+                });
+
+
+            migrationBuilder.CreateTable(
+                name: "Projects",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    ProposingBookNumber = table.Column<int>(type: "int", nullable: true),
+                    ProposingBookDate = table.Column<DateTime>(type: "datetime2", nullable: true),
+                    Name = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    Code = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    Description = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    AggreementNumber = table.Column<int>(type: "int", nullable: true),
+                    AggreementDate = table.Column<DateTime>(type: "datetime2", nullable: true),
+                    TeamLeaderId = table.Column<int>(type: "int", nullable: true),
+                    ExecuterId = table.Column<int>(type: "int", nullable: true),
+                    ProposerId = table.Column<int>(type: "int", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Projects", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Projects_Departments_ExecuterId",
+                        column: x => x.ExecuterId,
+                        principalTable: "Departments",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Employees",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    HIASTId = table.Column<int>(type: "int", nullable: false),
+                    FirstName = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    LastName = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    WorkingHours = table.Column<int>(type: "int", nullable: true),
+                    IsAvailable = table.Column<bool>(type: "bit", nullable: true),
+                    ProjectId = table.Column<int>(type: "int", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Employees", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Employees_Projects_ProjectId",
+                        column: x => x.ProjectId,
+                        principalTable: "Projects",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Steps",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    StepName = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    Description = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    Duration = table.Column<int>(type: "int", nullable: false),
+                    StartDate = table.Column<DateTime>(type: "datetime2", nullable: false),
+                    ProjectId = table.Column<int>(type: "int", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Steps", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Steps_Projects_ProjectId",
+                        column: x => x.ProjectId,
+                        principalTable: "Projects",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Tracks",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    TrackDate = table.Column<DateTime>(type: "datetime2", nullable: false),
+                    TrackNote = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    ProjectId = table.Column<int>(type: "int", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Tracks", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Tracks_Projects_ProjectId",
+                        column: x => x.ProjectId,
+                        principalTable: "Projects",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Items",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    ItemName = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    ItemDescription = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    Ammount = table.Column<int>(type: "int", nullable: true),
+                    Currency = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    StepId = table.Column<int>(type: "int", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Items", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Items_Steps_StepId",
+                        column: x => x.StepId,
+                        principalTable: "Steps",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "StepTracks",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    StepId = table.Column<int>(type: "int", nullable: true),
+                    TrackId = table.Column<int>(type: "int", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_StepTracks", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_StepTracks_Steps_StepId",
+                        column: x => x.StepId,
+                        principalTable: "Steps",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_StepTracks_Tracks_TrackId",
+                        column: x => x.TrackId,
+                        principalTable: "Tracks",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "EmployeeTraks",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    EmployeeId = table.Column<int>(type: "int", nullable: true),
+                    WorkingHour = table.Column<int>(type: "int", nullable: false),
+                    StepTrackId = table.Column<int>(type: "int", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_EmployeeTraks", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_EmployeeTraks_Employees_EmployeeId",
+                        column: x => x.EmployeeId,
+                        principalTable: "Employees",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_EmployeeTraks_StepTracks_StepTrackId",
+                        column: x => x.StepTrackId,
+                        principalTable: "StepTracks",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Employees_ProjectId",
+                table: "Employees",
+                column: "ProjectId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_EmployeeTraks_EmployeeId",
+                table: "EmployeeTraks",
+                column: "EmployeeId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_EmployeeTraks_StepTrackId",
+                table: "EmployeeTraks",
+                column: "StepTrackId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Items_StepId",
+                table: "Items",
+                column: "StepId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Projects_ExecuterId",
+                table: "Projects",
+                column: "ExecuterId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Projects_ProposerId",
+                table: "Projects",
+                column: "ProposerId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Projects_TeamLeaderId",
+                table: "Projects",
+                column: "TeamLeaderId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Steps_ProjectId",
+                table: "Steps",
+                column: "ProjectId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_StepTracks_StepId",
+                table: "StepTracks",
+                column: "StepId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_StepTracks_TrackId",
+                table: "StepTracks",
+                column: "TrackId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Tracks_ProjectId",
+                table: "Tracks",
+                column: "ProjectId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Projects_Employees_ProposerId",
+                table: "Projects",
+                column: "ProposerId",
+                principalTable: "Employees",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Restrict);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Projects_Employees_TeamLeaderId",
+                table: "Projects",
+                column: "TeamLeaderId",
+                principalTable: "Employees",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Restrict);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Employees_Projects_ProjectId",
+                table: "Employees");
+
+            migrationBuilder.DropTable(
+                name: "ContactInfo");
+
+            migrationBuilder.DropTable(
+                name: "EmployeeTraks");
+
+            migrationBuilder.DropTable(
+                name: "Items");
+
+            migrationBuilder.DropTable(
+                name: "Users");
+
+            migrationBuilder.DropTable(
+                name: "Customers");
+
+            migrationBuilder.DropTable(
+                name: "StepTracks");
+
+            migrationBuilder.DropTable(
+                name: "Steps");
+
+            migrationBuilder.DropTable(
+                name: "Tracks");
+
+            migrationBuilder.DropTable(
+                name: "Projects");
+
+            migrationBuilder.DropTable(
+                name: "Departments");
+
+            migrationBuilder.DropTable(
+                name: "Employees");
+        }
+    }
+}

PSManagement.Infrastructure.Persistence/Migrations/AppDbContextModelSnapshot.cs

 // <auto-generated />
+using System;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Metadata;
@@ -37,6 +38,41 @@ namespace PSManagement.Infrastructure.Persistence.Migrations
                     b.ToTable("Customers");
                 });
 
+            modelBuilder.Entity("PSManagement.Domain.Departments.Aggregate.Department", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Departments");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Employees.Aggregate.Employee", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int>("HIASTId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ProjectId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Employees");
+                });
+
             modelBuilder.Entity("PSManagement.Domain.Identity.Aggregate.User", b =>
                 {
                     b.Property<int>("Id")
@@ -61,6 +97,155 @@ namespace PSManagement.Infrastructure.Persistence.Migrations
                     b.ToTable("Users");
                 });
 
+            modelBuilder.Entity("PSManagement.Domain.Projects.Aggregate.Project", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int?>("ExecuterId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ProposerId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("TeamLeaderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ExecuterId");
+
+                    b.HasIndex("ProposerId");
+
+                    b.HasIndex("TeamLeaderId");
+
+                    b.ToTable("Projects");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Steps.Aggregate.Step", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Duration")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ProjectId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("StartDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("StepName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Steps");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Steps.Entities.Item", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("ItemDescription")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ItemName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("StepId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StepId");
+
+                    b.ToTable("Items");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Entities.EmployeeTrack", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int?>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("StepTrackId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkingHour")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("StepTrackId");
+
+                    b.ToTable("EmployeeTraks");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Entities.StepTrack", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int?>("StepId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("TrackId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StepId");
+
+                    b.HasIndex("TrackId");
+
+                    b.ToTable("StepTracks");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Track", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int?>("ProjectId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("TrackDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("TrackNote")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Tracks");
+                });
+
             modelBuilder.Entity("PSManagement.Domain.Customers.Aggregate.Customer", b =>
                 {
                     b.OwnsMany("PSManagement.Domain.Customers.Entities.ContactInfo", "ContactInfo", b1 =>
@@ -73,10 +258,10 @@ namespace PSManagement.Infrastructure.Persistence.Migrations
                                 .HasColumnType("int")
                                 .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
 
-                            b1.Property<string>("ConatctValue")
+                            b1.Property<string>("ContactType")
                                 .HasColumnType("nvarchar(max)");
 
-                            b1.Property<string>("ContactType")
+                            b1.Property<string>("ContactValue")
                                 .HasColumnType("nvarchar(max)");
 
                             b1.HasKey("CustomerId", "Id");
@@ -122,6 +307,259 @@ namespace PSManagement.Infrastructure.Persistence.Migrations
 
                     b.Navigation("ContactInfo");
                 });
+
+            modelBuilder.Entity("PSManagement.Domain.Employees.Aggregate.Employee", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Projects.Aggregate.Project", null)
+                        .WithMany("Participants")
+                        .HasForeignKey("ProjectId");
+
+                    b.OwnsOne("PSManagement.Domain.Employees.Aggregate.Availability", "Availability", b1 =>
+                        {
+                            b1.Property<int>("EmployeeId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<bool>("IsAvailable")
+                                .HasColumnType("bit")
+                                .HasColumnName("IsAvailable");
+
+                            b1.Property<int>("WorkingHours")
+                                .HasColumnType("int")
+                                .HasColumnName("WorkingHours");
+
+                            b1.HasKey("EmployeeId");
+
+                            b1.ToTable("Employees");
+
+                            b1.WithOwner()
+                                .HasForeignKey("EmployeeId");
+                        });
+
+                    b.OwnsOne("PSManagement.Domain.Employees.Aggregate.PersonalInfo", "PersonalInfo", b1 =>
+                        {
+                            b1.Property<int>("EmployeeId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("FirstName")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("FirstName");
+
+                            b1.Property<string>("LastName")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("LastName");
+
+                            b1.HasKey("EmployeeId");
+
+                            b1.ToTable("Employees");
+
+                            b1.WithOwner()
+                                .HasForeignKey("EmployeeId");
+                        });
+
+                    b.Navigation("Availability");
+
+                    b.Navigation("PersonalInfo");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Aggregate.Project", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Departments.Aggregate.Department", "Executer")
+                        .WithMany()
+                        .HasForeignKey("ExecuterId");
+
+                    b.HasOne("PSManagement.Domain.Employees.Aggregate.Employee", "Proposer")
+                        .WithMany()
+                        .HasForeignKey("ProposerId");
+
+                    b.HasOne("PSManagement.Domain.Employees.Aggregate.Employee", "TeamLeader")
+                        .WithMany()
+                        .HasForeignKey("TeamLeaderId");
+
+                    b.OwnsOne("PSManagement.Domain.Projects.Aggregate.Aggreement", "ProjectAggreement", b1 =>
+                        {
+                            b1.Property<int>("ProjectId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<DateTime>("AggreementDate")
+                                .HasColumnType("datetime2")
+                                .HasColumnName("AggreementDate");
+
+                            b1.Property<int>("AggreementNumber")
+                                .HasColumnType("int")
+                                .HasColumnName("AggreementNumber");
+
+                            b1.HasKey("ProjectId");
+
+                            b1.ToTable("Projects");
+
+                            b1.WithOwner()
+                                .HasForeignKey("ProjectId");
+                        });
+
+                    b.OwnsOne("PSManagement.Domain.Projects.Aggregate.ProjectInfo", "ProjectInfo", b1 =>
+                        {
+                            b1.Property<int>("ProjectId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("Code")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("Code");
+
+                            b1.Property<string>("Description")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("Description");
+
+                            b1.Property<string>("Name")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("Name");
+
+                            b1.HasKey("ProjectId");
+
+                            b1.ToTable("Projects");
+
+                            b1.WithOwner()
+                                .HasForeignKey("ProjectId");
+                        });
+
+                    b.OwnsOne("PSManagement.Domain.Projects.Aggregate.ProposalInfo", "ProposalInfo", b1 =>
+                        {
+                            b1.Property<int>("ProjectId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<DateTime>("ProposingBookDate")
+                                .HasColumnType("datetime2")
+                                .HasColumnName("ProposingBookDate");
+
+                            b1.Property<int>("ProposingBookNumber")
+                                .HasColumnType("int")
+                                .HasColumnName("ProposingBookNumber");
+
+                            b1.HasKey("ProjectId");
+
+                            b1.ToTable("Projects");
+
+                            b1.WithOwner()
+                                .HasForeignKey("ProjectId");
+                        });
+
+                    b.Navigation("Executer");
+
+                    b.Navigation("ProjectAggreement");
+
+                    b.Navigation("ProjectInfo");
+
+                    b.Navigation("ProposalInfo");
+
+                    b.Navigation("Proposer");
+
+                    b.Navigation("TeamLeader");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Steps.Aggregate.Step", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Projects.Aggregate.Project", null)
+                        .WithMany("Steps")
+                        .HasForeignKey("ProjectId");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Steps.Entities.Item", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Steps.Aggregate.Step", null)
+                        .WithMany("Purchases")
+                        .HasForeignKey("StepId");
+
+                    b.OwnsOne("PSManagement.SharedKernel.ValueObjects.Money", "Price", b1 =>
+                        {
+                            b1.Property<int>("ItemId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<int>("Ammount")
+                                .HasColumnType("int")
+                                .HasColumnName("Ammount");
+
+                            b1.Property<string>("Currency")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("Currency");
+
+                            b1.HasKey("ItemId");
+
+                            b1.ToTable("Items");
+
+                            b1.WithOwner()
+                                .HasForeignKey("ItemId");
+                        });
+
+                    b.Navigation("Price");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Entities.EmployeeTrack", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Employees.Aggregate.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId");
+
+                    b.HasOne("PSManagement.Domain.Tracking.Entities.StepTrack", null)
+                        .WithMany("EmployeeTracks")
+                        .HasForeignKey("StepTrackId");
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Entities.StepTrack", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Steps.Aggregate.Step", "Step")
+                        .WithMany()
+                        .HasForeignKey("StepId");
+
+                    b.HasOne("PSManagement.Domain.Tracking.Track", null)
+                        .WithMany("StepsTracks")
+                        .HasForeignKey("TrackId");
+
+                    b.Navigation("Step");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Track", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Projects.Aggregate.Project", "Project")
+                        .WithMany()
+                        .HasForeignKey("ProjectId");
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Aggregate.Project", b =>
+                {
+                    b.Navigation("Participants");
+
+                    b.Navigation("Steps");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Steps.Aggregate.Step", b =>
+                {
+                    b.Navigation("Purchases");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Entities.StepTrack", b =>
+                {
+                    b.Navigation("EmployeeTracks");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Track", b =>
+                {
+                    b.Navigation("StepsTracks");
+                });
 #pragma warning restore 612, 618
         }
     }

PSManagement.Infrastructure/Services/Authentication/AuthenticationService.cs

-using FluentResults;
+
+using FluentResults;
 using PSManagement.Application.Contracts.Authentication;
 using PSManagement.Application.Contracts.Authorization;
+using PSManagement.Domain.Customers.DomainErrors;
 using PSManagement.Domain.Identity.Aggregate;
 using PSManagement.Domain.Identity.DomainErrors;
 using PSManagement.Domain.Identity.Repositories;
-//using PSManagement.SharedKernel.Utilities;
+
 using System;
 using System.Threading.Tasks;
 
@@ -25,7 +27,7 @@ namespace PSManagement.Infrastructure.Services.Authentication
             
             User u = await _userRepository.GetByEmail(email);
             if (u is null || u.HashedPassword != password) {
-                return Result.Fail<AuthenticationResult>(new InvalidLoginDataError());
+                return Result.Fail<AuthenticationResult>(UserErrors.InvalidLoginAttempt);
 
             }
             String token = _jwtTokenGenerator.GenerateToken(u.Id,u.FirstName,u.LastName,u.Email);
@@ -41,7 +43,7 @@ namespace PSManagement.Infrastructure.Services.Authentication
             // check if the user exist 
             var u = await _userRepository.GetByEmail(email);
             if (u is not null) {
-                return Result.Fail<AuthenticationResult>(new AlreadyExistError());
+                return Result.Fail(UserErrors.AlreadyUserExist);
             }
             var user = await _userRepository.AddAsync(
                 new User{

PSManagement.SharedKernel/DomainErrors/IDomainError.cs → PSManagement.SharedKernel/DomainErrors/DomainError.cs

@@ -7,8 +7,18 @@ using System.Threading.Tasks;
 
 namespace PSManagement.SharedKernel.DomainErrors
 {
-    public interface IDomainError : IError
+    public class DomainError : Error
     {
+        public DomainError(string message) : base(message)
+        {
+        }
 
+        public DomainError(string message, IError causedBy) : base(message, causedBy)
+        {
+        }
+
+        protected DomainError()
+        {
+        }
     }
 }

PSManagement.SharedKernel/PSManagement.SharedKernel.csproj

@@ -6,7 +6,7 @@
 
   <ItemGroup>
     <PackageReference Include="FluentResults" Version="3.16.0" />
-    <PackageReference Include="MediatR" Version="5.1.0" />
+    <PackageReference Include="MediatR" Version="8.0.1" />
   </ItemGroup>
 
 </Project>

PSManagement.SharedKernel/Utilities/Error.cs

@@ -8,8 +8,8 @@ namespace PSManagement.SharedKernel.Utilities
 {
     public record Error(string Code, string Name)
     {
-        public static Error None = new(string.Empty, string.Empty);
+        public static readonly Error None = new(string.Empty, string.Empty);
 
-        public static Error NullValue = new("Error.NullValue", "Null value was provided");
+        public static readonly Error NullValue = new("Error.NullValue", "Null value was provided");
     }
 }

PSManagement.SharedKernel/Utilities/Result.cs

@@ -27,7 +27,7 @@ namespace PSManagement.SharedKernel.Utilities
 
         public bool IsSuccess { get; }
 
-        public bool IsFailure => !IsSuccess;
+        public bool IsFail => !IsSuccess;
 
         public Error Error { get; }
 

PSManagement.SharedKernel/ValueObjects/Money.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PSManagement.SharedKernel.ValueObjects
+{
+    public record Money(
+        int Ammount , 
+        String Currency 
+        );
+}