fix s.

PSManagement.Api/Controllers/Customers/CustomersController.cs

@@ -18,6 +18,7 @@ using PSManagement.Contracts.Customers.Responses;
 using PSManagement.Application.Customers.UseCases.Queries.GetCustomer;
 using PSManagement.Api.Controllers.ApiBase;
 using Ardalis.Result;
+using PSManagement.Application.Customers.UseCases.Commands.RemoveContactInfo;
 
 namespace PSManagement.Api.Controllers.Customers
 {
@@ -35,36 +36,53 @@ namespace PSManagement.Api.Controllers.Customers
         }
 
         [HttpGet]
-        public async Task<IActionResult> ListCustomers()
+        public async Task<IActionResult> Get()
         {
             var query = new ListAllCustomersQuery();
 
-            var result = _mapper.Map<Result<IEnumerable<CustomerRecord>>>( await _sender.Send(query));
+            var result = _mapper.Map<Result<IEnumerable<CustomerResponse>>>( await _sender.Send(query));
          
             return Ok(result);
         }
 
         [HttpGet("{id}")]
-        public async Task<IActionResult> GetCustomer(int id )
+        public async Task<IActionResult> Get(int id )
         {
             var query = new GetCustomerQuery(id);
 
             var result = await _sender.Send(query);
 
 
-            return Ok(_mapper.Map<Result<CustomerRecord>>(result));
+            return Ok(_mapper.Map<Result<CustomerResponse>>(result));
         }
         [HttpPost]
-        public async Task<IActionResult> CreateCustomer(CreateCustomerRequest request)
+        public async Task<IActionResult> Post(CreateCustomerRequest request)
         {
             var command = _mapper.Map<CreateCustomerCommand>(request);
 
             var result = await _sender.Send(command);
+
+            if (result.IsSuccess)
+            {
+
+                var query = new GetCustomerQuery(result.Value);
+
+                var response = await _sender.Send(query);
+
+                return Ok(_mapper.Map<CustomerResponse>(response));
+
+            }
+            else
+            {
+
                 return Ok(result);
+
+            }
+
         }
         
         [HttpDelete]
-        public async Task<IActionResult> DeleteCustomer(DeleteCustomerRequest request)
+        public async Task<IActionResult> Delete(DeleteCustomerRequest request)
         {
             var command = _mapper.Map<DeleteCustomerCommand>(request);
 
@@ -73,8 +91,9 @@ namespace PSManagement.Api.Controllers.Customers
             return Ok(result);
 
         }
+
         [HttpPut("{id}")]
-        public async Task<IActionResult> UpdateCustomer(int id ,UpdateCustomerRequest request)
+        public async Task<IActionResult> Put(int id ,UpdateCustomerRequest request)
         {
             if(id != request.CustomerId){
                 return Problem();
@@ -89,7 +108,7 @@ namespace PSManagement.Api.Controllers.Customers
 
 
         [HttpPost("AddContactInfo")]
-        public async Task<IActionResult> AddContactInfo(AddContactInfoRequest request)
+        public async Task<IActionResult> PostContactInfo(AddContactInfoRequest request)
         {
             var command = _mapper.Map<AddContactInfoCommand>(request);
 
@@ -99,6 +118,16 @@ namespace PSManagement.Api.Controllers.Customers
         }
 
 
+        [HttpDelete("RemoveContactInfo")]
+        public async Task<IActionResult> DeleteContactInfo(RemoveContactInfoRequest request)
+        {
+            var command = _mapper.Map<RemoveContactInfoCommand>(request);
+
+            var result = await _sender.Send(command);
+
+            return Ok(result);
+        }
+
 
     }
 }

PSManagement.Api/Mappers/CustomerMapperConfiguration.cs

@@ -32,12 +32,12 @@ namespace PSManagement.Api.Mappers
             CreateMap<UpdateCustomerCommand, UpdateCustomerRequest>().ReverseMap();
 
             CreateMap<AddContactInfoRequest, AddContactInfoCommand>().ReverseMap();
-            CreateMap<CustomerDTO, CustomerRecord>();
-            CreateMap<ContactInfoDTO, ContactInfoRecord>();
+            CreateMap<CustomerDTO, CustomerResponse>();
+            CreateMap<ContactInfoDTO, ContactInfoResponse>();
 
-            CreateMap<CustomerRecord, CustomerDTO>().ReverseMap();
+            CreateMap<CustomerResponse, CustomerDTO>().ReverseMap();
             
-            CreateMap<IEnumerable<CustomerRecord>, ListCustomersResponse>()
+            CreateMap<IEnumerable<CustomerResponse>, ListCustomersResponse>()
                     .ConstructUsing(src => new ListCustomersResponse(src));
             
         }

PSManagement.Application/Behaviors/ValidationBehavior/ValidationBehavior.cs

@@ -24,7 +24,8 @@ namespace PSManagement.Application.Behaviors.ValidationBehavior
 
         public async Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next)
         {
-            if (_validators is null) {
+            if (_validators is null)
+            {
 
                 return await next();
             }
@@ -34,7 +35,7 @@ namespace PSManagement.Application.Behaviors.ValidationBehavior
 
             var errors = validationResults.SelectMany(r => r.Errors)
                                             .Where(e => e != null)
-                                            .Select(e => new ValidationError(e.ErrorCode,e.ErrorMessage,e.ErrorCode,new ValidationSeverity()))
+                                            .Select(e => new ValidationError(e.ErrorCode, e.ErrorMessage, e.ErrorCode, new ValidationSeverity()))
                                             .ToList();
 
             if (errors.Any())
@@ -45,28 +46,5 @@ namespace PSManagement.Application.Behaviors.ValidationBehavior
 
             return await next();
         }
-        private Result ValidateAsync(TRequest request)
-        {
-            var context = new ValidationContext<TRequest>(request);
-
-            var failures = _validators
-                .Select(v => v.Validate(context))
-                .SelectMany(result => result.Errors)
-                .Where(f => f != null)
-                .ToList();
-            if (failures.Count != 0)
-            {
-
-                var result = Result.Invalid(new ValidationError("validation Error."));
-                //foreach (var failure in failures)
-                //{
-                //    result.Reasons.Add(new Error(failure.ErrorMessage));
-                //}
-                return  result;
-                
-            }
-
-            return Result.Success();
-        }
     }
 }

PSManagement.Application/Customers/Events/CustomerCreatedEventHandler.cs

-using PSManagement.Domain.Customers.DomainEvents;
+using Microsoft.Extensions.Logging;
+using PSManagement.Application.Contracts.Providers;
+using PSManagement.Domain.Customers.DomainEvents;
+using PSManagement.Domain.Customers.Entities;
 using PSManagement.SharedKernel.DomainEvents;
 using System;
 using System.Collections.Generic;
@@ -11,10 +14,22 @@ namespace PSManagement.Application.Customers.Events
 {
     public class CustomerCreatedEventHandler : IDomainEventHandler<CutsomerCreatedEvent>
     {
+        private readonly ILogger<Customer> _logger;
+        private readonly IDateTimeProvider _dateTimeProvider;
+
+        public CustomerCreatedEventHandler(
+            ILogger<Customer> logger,
+            IDateTimeProvider dateTimeProvider)
+        {
+            _logger = logger;
+            _dateTimeProvider = dateTimeProvider;
+        }
+
         public  Task Handle(CutsomerCreatedEvent notification, CancellationToken cancellationToken)
         {
 
-            Console.WriteLine("fdgfg");
+            _logger.LogInformation("new customer Added at "+_dateTimeProvider.UtcNow);
+
             return Task.CompletedTask;
 
         }

PSManagement.Application/Customers/UseCases/Commands/RemoveContactInfo/RemoveContactInfoCommand.cs

+using Ardalis.Result;
+using PSManagement.SharedKernel.CQRS.Command;
+
+namespace PSManagement.Application.Customers.UseCases.Commands.RemoveContactInfo
+{
+    public record RemoveContactInfoCommand(
+        int Id,
+        int CustomerId) : ICommand<Result>;
+
+}

PSManagement.Application/Customers/UseCases/Commands/RemoveContactInfo/RemoveContactInfoCommandHandler.cs

+using Ardalis.Result;
+using PSManagement.Domain.Customers.DomainErrors;
+using PSManagement.Domain.Customers.Entities;
+using PSManagement.Domain.Customers.Repositories;
+using PSManagement.SharedKernel.CQRS.Command;
+using PSManagement.SharedKernel.Repositories;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace PSManagement.Application.Customers.UseCases.Commands.RemoveContactInfo
+{
+    public class RemoveContactInfoCommandHandler : ICommandHandler<RemoveContactInfoCommand, Result>
+    {
+        private readonly ICustomersRepository _customersRepository;
+        private readonly IRepository<ContactInfo> _contactsRepository;
+
+        public RemoveContactInfoCommandHandler(
+            ICustomersRepository customersRepository,
+            IRepository<ContactInfo> contactsRepository)
+        {
+            _customersRepository = customersRepository;
+            _contactsRepository = contactsRepository;
+        }
+
+        public async Task<Result> Handle(RemoveContactInfoCommand request, CancellationToken cancellationToken)
+        {
+            Customer customer = await _customersRepository.GetByIdAsync(request.CustomerId);
+
+            if (customer is null)
+            {
+
+                return Result.Invalid(CustomerErrors.InvalidEntryError);
+            }
+
+            ContactInfo contact = await _contactsRepository.GetByIdAsync(request.Id);
+            
+            if (contact is null) {
+                return Result.Invalid(CustomerErrors.InvalidEntryError);
+            }
+
+            await _contactsRepository.DeleteAsync(contact);
+            return Result.Success();
+        }
+    }
+
+}

PSManagement.Application/Customers/UseCases/Commands/UpdateCustomer/UpdateCustomerCommandHandler.cs

@@ -27,8 +27,10 @@ namespace PSManagement.Application.Customers.UseCases.Commands.UpdateCustomer
         public async Task<Result> Handle(UpdateCustomerCommand request, CancellationToken cancellationToken)
         {
 
-            Customer customer = new (request.CustomerName ,request.Address,request.Email);
-            customer.Id = request.CustomerId;
+            Customer customer = await  _customerRepository.GetByIdAsync(request.CustomerId);
+            customer.Email = request.Email;
+            customer.CustomerName = request.CustomerName;
+            customer.Address = request.Address;
 
             await _customerRepository.UpdateAsync(customer);
             

PSManagement.Application/Customers/UseCases/Queries/GetCustomerById/GetCustomerQuery.cs

@@ -7,6 +7,6 @@ using System.Text;
 
 namespace PSManagement.Application.Customers.UseCases.Queries.GetCustomer
 {
-    public record  GetCustomerQuery(int customerId) : IQuery<Result<CustomerDTO>>;
+    public record  GetCustomerQuery(int CustomerId) : IQuery<Result<CustomerDTO>>;
 
 }

PSManagement.Application/Customers/UseCases/Queries/GetCustomerById/GetCustomerQueryHandler.cs

@@ -4,7 +4,9 @@ using PSManagement.Application.Customers.Common;
 using PSManagement.Domain.Customers.DomainErrors;
 using PSManagement.Domain.Customers.Entities;
 using PSManagement.Domain.Customers.Repositories;
+using PSManagement.Domain.Customers.Specification;
 using PSManagement.SharedKernel.CQRS.Query;
+using PSManagement.SharedKernel.Specification;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
@@ -15,18 +17,23 @@ namespace PSManagement.Application.Customers.UseCases.Queries.GetCustomer
     {
         private readonly ICustomersRepository _customersRepository;
         private readonly IMapper _mapper;
+        private readonly BaseSpecification<Customer> _specification ;
         public GetCustomerQueryHandler(ICustomersRepository customersRepository, IMapper mapper)
         {
             _customersRepository = customersRepository;
             _mapper = mapper;
+            _specification = new CustomerSpecification();
         }
 
         public async Task<Result<CustomerDTO>> Handle(GetCustomerQuery request, CancellationToken cancellationToken)
         {
-            Customer customer = await _customersRepository.GetByIdAsync(request.customerId);
+            Customer customer = await _customersRepository.GetByIdAsync(request.CustomerId,_specification);
+            
             if (customer is null) {
-                return Result.NotFound(CustomerErrors.InvalidEntryError.ErrorMessage);
+
+                return Result.Invalid(CustomerErrors.InvalidEntryError);
             }
+
             return Result.Success(_mapper.Map<CustomerDTO>(customer));
 
         }

PSManagement.Application/Employees/Common/EmployeeDTO.cs

@@ -15,6 +15,7 @@ namespace PSManagement.Application.Employees.Common
         public String DepartmentName { get; set; }
         public PersonalInfo PersonalInfo { get; set; }
         public WorkInfo WorkInfo { get; set; }
+        public Availability Availability { get; set; }
 
     }
 }

PSManagement.Application/Employees/UseCases/Queries/GetEmployeeById/GetEmployeeByIdQueryHandler.cs

@@ -28,7 +28,7 @@ namespace PSManagement.Application.Employees.UseCases.Queries.GetEmployeeById
 
         public async Task<Result<EmployeeDTO>> Handle(GetEmployeeByIdQuery request, CancellationToken cancellationToken)
         {
-           
+            _specification.AddInclude(e => e.Department);
             return Result.Success(_mapper.Map<EmployeeDTO>(await _employeesRepository.GetByIdAsync(request.EmployeeId,_specification)));
         }
     }

PSManagement.Application/Employees/UseCases/Queries/GetEmployeeParticipations/GetEmployeeParticipationQueryHandler.cs

@@ -38,6 +38,8 @@ namespace PSManagement.Application.Employees.UseCases.Queries.GetEmployeeById
             _specification.AddInclude("Employee.Department");
 
             _specification.AddInclude(e => e.Employee);
+            _specification.AddInclude(e => e.Employee.Department);
+
 
             IEnumerable<EmployeeParticipate> response = await _employeesParticipateRepository.ListAsync(_specification);
 

PSManagement.Application/FinancialSpends/UseCases/Commands/CreateFinancialSpendItem/CreateFinancialSpendItemCommandHandler.cs

@@ -17,21 +17,17 @@ namespace PSManagement.Application.FinancialSpends.UseCases.Commands.CreateFinan
         private readonly IProjectsRepository _projectsRepository;
         private readonly IFinancialSpendingRepository _spendRepository;
         private readonly IUnitOfWork _unitOfWork;
-        private readonly IMapper _mapper;
-
-
 
 
         public CreateFinancialSpendItemCommandHandler(
             IFinancialSpendingRepository spendRepository,
             IProjectsRepository projectsRepository,
-            IUnitOfWork unitOfWork, 
-            IMapper mapper)
+            IUnitOfWork unitOfWork
+            )
         {
             _spendRepository = spendRepository;
             _projectsRepository = projectsRepository;
             _unitOfWork = unitOfWork;
-            _mapper = mapper;
         }
 
 

PSManagement.Application/PSManagement.Application.csproj

@@ -7,7 +7,6 @@
 
   <ItemGroup>
     <Folder Include="Behaviors\AuthorizationBehavior\" />
-    <Folder Include="Customers\UseCases\Commands\RemoveContactInfo\" />
     <Folder Include="Tracks\EventsHandlers\" />
   </ItemGroup>
 

PSManagement.Application/Projects/UseCases/Commands/AddParticipant/AddParticipantCommandHandler.cs

@@ -41,7 +41,8 @@ namespace PSManagement.Application.Projects.UseCases.Commands.AddParticipant
 
         public async Task<Result> Handle(AddParticipantCommand request, CancellationToken cancellationToken)
         {
-            _specification.Includes.Add(p => p.EmployeeParticipates);
+            _specification.AddInclude(e => e.EmployeeParticipates);
+
             Project project =await _projectsRepository.GetByIdAsync(request.ProjectId,_specification);
             if (project is null)
             {
@@ -54,12 +55,14 @@ namespace PSManagement.Application.Projects.UseCases.Commands.AddParticipant
                     return Result.Invalid(ProjectsErrors.ParticipantExistError);
                 }
                 else {
+                    
                     Employee employee = await _employeesRepository.GetByIdAsync(request.ParticipantId);
                     if (employee is null) {
 
                         return Result.Invalid(EmployeesErrors.EmployeeUnExist);
 
                     }
+
                     await _employeeParticipateRepository.AddAsync(new (request.ParticipantId,request.ProjectId,request.Role,request.PartialTimeRatio));
                     
                     project.AddDomainEvent(new ParticipantAddedEvent(request.ParticipantId,request.ProjectId,request.PartialTimeRatio,request.Role));

PSManagement.Application/Projects/UseCases/Commands/CancelProject/CancelProjectCommandHandler.cs

 using Ardalis.Result;
+using PSManagement.Application.Contracts.Providers;
 using PSManagement.Domain.Projects.DomainErrors;
 using PSManagement.Domain.Projects.Entities;
 using PSManagement.Domain.Projects.Repositories;
@@ -13,16 +14,17 @@ namespace PSManagement.Application.Projects.UseCases.Commands.CancelProject
     {
         private readonly IProjectsRepository _projectsRepository;
         private readonly IUnitOfWork _unitOfWork;
+        private readonly IDateTimeProvider _dateTime;
 
         public CancelProjectCommandHandler(
             IProjectsRepository projectsRepository,
-            IUnitOfWork unitOfWork
-            )
+            IUnitOfWork unitOfWork,
+            IDateTimeProvider dateTime)
         {
 
             _projectsRepository = projectsRepository;
             _unitOfWork = unitOfWork;
-
+            _dateTime = dateTime;
         }
 
         public async Task<Result> Handle(CancelProjectCommand request, CancellationToken cancellationToken)
@@ -35,7 +37,7 @@ namespace PSManagement.Application.Projects.UseCases.Commands.CancelProject
             else
             {
 
-                project.Cancle();
+                project.Cancel(_dateTime.UtcNow);
                 await _unitOfWork.SaveChangesAsync();
 
                 return Result.Success();

PSManagement.Application/Projects/UseCases/Commands/RemoveParticipant/RemoveParticipantCommandHandler.cs

 using Ardalis.Result;
+using PSManagement.Domain.Projects;
 using PSManagement.Domain.Projects.DomainErrors;
 using PSManagement.Domain.Projects.DomainEvents;
 using PSManagement.Domain.Projects.Entities;
@@ -6,6 +7,7 @@ using PSManagement.Domain.Projects.Repositories;
 using PSManagement.SharedKernel.CQRS.Command;
 using PSManagement.SharedKernel.Interfaces;
 using PSManagement.SharedKernel.Repositories;
+using PSManagement.SharedKernel.Specification;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -17,6 +19,7 @@ namespace PSManagement.Application.Projects.UseCases.Commands.RemoveParticipant
         private readonly IProjectsRepository _projectsRepository;
         private readonly IRepository<EmployeeParticipate> _employeeParticipateRepository;
         private readonly IUnitOfWork _unitOfWork;
+        private readonly BaseSpecification<Project> _specification;
 
         public AddParticipantCommandHandler(
             IRepository<EmployeeParticipate> repository,
@@ -24,37 +27,41 @@ namespace PSManagement.Application.Projects.UseCases.Commands.RemoveParticipant
             IUnitOfWork unitOfWork)
         {
             _employeeParticipateRepository = repository;
-
+            _specification = new ProjectSpecification();
             _projectsRepository = projectsRepository;
             _unitOfWork = unitOfWork;
         }
 
         public async Task<Result> Handle(RemoveParticipantCommand request, CancellationToken cancellationToken)
         {
-            Project project = await _projectsRepository.GetByIdAsync(request.ProjectId);
+            _specification.AddInclude(e => e.EmployeeParticipates);
+
+            Project project = await _projectsRepository.GetByIdAsync(request.ProjectId,_specification);
             if (project is null)
             {
                 return Result.Invalid(ProjectsErrors.InvalidEntryError);
             }
             else
             {
+                if (project.EmployeeParticipates is null) {
 
-                if (project.EmployeeParticipates?.Where(e => e.Id == request.ParticipantId) is null)
-                {
+                    return Result.Invalid(ProjectsErrors.ParticipantUnExistError);
+                
+                }
+                var employeeParticipate =project.EmployeeParticipates.Where(e => e.ProjectId == request.ParticipantId).FirstOrDefault();
+                if (employeeParticipate is null) {
 
                     return Result.Invalid(ProjectsErrors.ParticipantUnExistError);
                 }
-                else
-                {
-                    EmployeeParticipate participant = await _employeeParticipateRepository.GetByIdAsync(request.ParticipantId);
 
-                    await _employeeParticipateRepository.DeleteAsync(participant);
+                
+               await _employeeParticipateRepository.DeleteAsync(employeeParticipate);
+     
                project.AddDomainEvent(new ParticipantRemovedEvent(request.ParticipantId, request.ProjectId));
 
                await _unitOfWork.SaveChangesAsync();
 
                 return Result.Success();
-                }
 
 
             }

PSManagement.Application/Tracks/UseCaes/Commands/UpdateEmployeeWorkTrack/UpdateEmployeeWorkTrackCommandHandler.cs

@@ -15,19 +15,14 @@ namespace PSManagement.Application.Tracks.UseCaes.Commands.UpdateEmployeeWorkTra
     {
         private readonly IRepository<EmployeeTrack> _employeeTracksRepository;
         private readonly ITracksRepository _tracksRepository;
-        private readonly IUnitOfWork _unitOfWork;
-        private readonly IMapper _mapper;
         
         public UpdateEmployeeWorkTrackCommandHandler(
-            IUnitOfWork unitOfWork,
             ITracksRepository tracksRepository,
-            IRepository<EmployeeTrack> employeeTracksRepository,
-            IMapper mapper)
+            IRepository<EmployeeTrack> employeeTracksRepository
+            )
         {
-            _unitOfWork = unitOfWork;
             _tracksRepository = tracksRepository;
             _employeeTracksRepository = employeeTracksRepository;
-            _mapper = mapper;
         }
 
         public async Task<Result> Handle(UpdateEmployeeWorkTrackCommand request, CancellationToken cancellationToken)

PSManagement.Contracts/Customers/Requests/AddContactInfoRequest.cs

@@ -10,4 +10,5 @@ namespace PSManagement.Contracts.Customers.Requests
         int CustomerId,
         String ContactType,
         String ContactValue);
+
 }

PSManagement.Contracts/Customers/Requests/RemoveContactInfoRequest.cs

+namespace PSManagement.Contracts.Customers.Requests
+{
+    public record RemoveContactInfoRequest(
+    int Id,
+    int CustomerId) ;
+
+}

PSManagement.Contracts/Customers/Responses/ContactInfoRecord.cs → PSManagement.Contracts/Customers/Responses/ContactInfoResponse.cs

@@ -2,7 +2,7 @@
 
 namespace PSManagement.Contracts.Customers.Responses
 {
-    public class ContactInfoRecord {
+    public class ContactInfoResponse {
         public String ContactType { get; set; }
         public String ContactValue { get; set; }
     }

PSManagement.Contracts/Customers/Responses/CustomerRecord.cs → PSManagement.Contracts/Customers/Responses/CustomerResponse.cs

@@ -5,8 +5,8 @@ using System.Collections.Generic;
 
 namespace PSManagement.Contracts.Customers.Responses
 {
-    public class CustomerRecord {
-        public CustomerRecord()
+    public class CustomerResponse {
+        public CustomerResponse()
         {
 
         }
@@ -15,6 +15,6 @@ namespace PSManagement.Contracts.Customers.Responses
         public String CustomerName { get; set; }
         public String Email { get; set; }
         public Address Address { get; set; }
-        public IEnumerable<ContactInfoRecord> ContactInfo { get; set; }
+        public IEnumerable<ContactInfoResponse> ContactInfo { get; set; }
     }
 }

PSManagement.Contracts/Customers/Responses/ListCustomersResponse.cs

@@ -5,6 +5,6 @@ using System.Threading.Tasks;
 
 namespace PSManagement.Contracts.Customers.Responses
 {
-    public record  ListCustomersResponse( IEnumerable<CustomerRecord> Customers );
+    public record  ListCustomersResponse( IEnumerable<CustomerResponse> Customers );
     
 }

PSManagement.Contracts/Employees/Response/EmployeeResponse.cs

@@ -9,6 +9,7 @@ namespace PSManagement.Contracts.Projects.Response
         public int UserId { get; set; }
         public string DepartmentName { get; set; }
         public PersonalInfo PersonalInfo { get; set; }
+        public Availability Availability { get; set; }
         public WorkInfo WorkInfo { get; set; }
     }
 }
\ No newline at end of file

PSManagement.Contracts/Projects/Response/ProjectResponse.cs

@@ -22,7 +22,7 @@ namespace PSManagement.Contracts.Projects.Response
         public Department Executer { get; set; }
 
         public int ProposerId { get; private set; }
-        public CustomerRecord Proposer { get; set; }
+        public CustomerResponse Proposer { get; set; }
         public ICollection<StepResponse> Steps { get; set; }
         public ICollection<Attachment> Attachments { get; set; }
 

PSManagement.Domain/Customers/Specification/CustomerSpecification.cs

+using PSManagement.Domain.Customers.Entities;
+using PSManagement.SharedKernel.Specification;
+using System;
+using System.Linq.Expressions;
+
+namespace PSManagement.Domain.Customers.Specification
+{
+    public class CustomerSpecification : BaseSpecification<Customer>
+    {
+        public CustomerSpecification(Expression<Func<Customer, bool>> criteria = null) : base(criteria)
+        {
+
+            AddInclude(e => e.ContactInfo);
+        }
+    }
+}

PSManagement.Domain/Customers/ValueObjects/Address.cs

@@ -9,7 +9,6 @@ namespace PSManagement.Domain.Customers.ValueObjects
 {
     public record Address(
          int StreetNumber ,
-         int ZipCode ,
          String StreetName ,
          String City );
 }

PSManagement.Domain/Projects/Builders/ProjectBuilder.cs

@@ -89,6 +89,7 @@ namespace PSManagement.Domain.Projects.Builders
         }
         public ProjectBuilder WithAttachment(Attachment[] attachments)
         {
+            _attachments = new List<Attachment>();
             foreach (Attachment attachment in attachments) {
                 _attachments.Add(attachment);
             }

PSManagement.Domain/Projects/Entities/Project.cs

@@ -20,10 +20,11 @@ namespace PSManagement.Domain.Projects.Entities
         public ProposalInfo ProposalInfo { get; set; }
         public ProjectInfo ProjectInfo { get; set; }
         public Aggreement ProjectAggreement { get; set; }
+      
         // state management 
-        [NotMapped]
         public string CurrentState { get; private set; }  // Persisted in the database
         
+        [NotMapped]
         private IProjectState _state;
 
         // information about who lead and execute the project 
@@ -95,16 +96,16 @@ namespace PSManagement.Domain.Projects.Entities
             Participants = new List<Employee>();
             EmployeeParticipates = new List<EmployeeParticipate>();
             
+
         }
         public Project()
         {
-            _state = new ProposedState();
-            CurrentState = _state.StateName;
+            SetStateFromString(CurrentState);
         }
         public void SetState(IProjectState newState)
         {
             _state = newState;
-            CurrentState = _state.StateName;  // Update the persisted state
+            CurrentState = _state.StateName; 
         }
         public void Complete() 
         {
@@ -121,9 +122,9 @@ namespace PSManagement.Domain.Projects.Entities
             _state.Approve(this,projectAggreement);
 
         }
-        public void Cancle()
+        public void Cancel(DateTime canellationTime)
         {
-            _state.Cancle(this);
+            _state.Cancel(this,canellationTime);
 
         }
         public void Propose()

PSManagement.Domain/Projects/States/CancledState.cs

 using PSManagement.Domain.Projects.ValueObjects;
+using System;
 
 namespace PSManagement.Domain.Projects.Entities
 {
@@ -11,7 +12,7 @@ namespace PSManagement.Domain.Projects.Entities
 
         }
 
-        public void Cancle(Project project)
+        public void Cancel(Project project, DateTime canellationTime)
         {
         
         }

PSManagement.Domain/Projects/States/CompletedState.cs

 using PSManagement.Domain.Projects.ValueObjects;
+using System;
 
 namespace PSManagement.Domain.Projects.Entities
 {
@@ -11,7 +12,7 @@ namespace PSManagement.Domain.Projects.Entities
 
         }
 
-        public void Cancle(Project project)
+        public void Cancel(Project project, DateTime canellationTime)
         {
 
         }

PSManagement.Domain/Projects/States/IProjectState.cs

 using PSManagement.Domain.Projects.ValueObjects;
+using System;
 
 namespace PSManagement.Domain.Projects.Entities
 {
@@ -7,7 +8,7 @@ namespace PSManagement.Domain.Projects.Entities
         void Complete(Project project);
         void Plan(Project project);
         void Approve(Project project, Aggreement projectAggreement);
-        void Cancle(Project project);
+        void Cancel(Project project, DateTime canellationTime);
         void Propose(Project project);
         string StateName { get; }
     }

PSManagement.Domain/Projects/States/InPlanState.cs

@@ -16,7 +16,7 @@ namespace PSManagement.Domain.Projects.Entities
             project.SetState(new InProgressState());
         }
 
-        public void Cancle(Project project)
+        public void Cancel(Project project, DateTime canellationTime)
         {
             project.AddDomainEvent(new ProjectCancelledEvent(project.Id,DateTime.Now));
             project.SetState(new CancledState());

PSManagement.Domain/Projects/States/InProgressState.cs

@@ -13,9 +13,9 @@ namespace PSManagement.Domain.Projects.Entities
 
         }
 
-        public void Cancle(Project project)
+        public void Cancel(Project project, DateTime canellationTime)
         {
-            project.AddDomainEvent(new ProjectCancelledEvent(project.Id, DateTime.Now));
+            project.AddDomainEvent(new ProjectCancelledEvent(project.Id,canellationTime));
             project.SetState(new CancledState());
         }
 

PSManagement.Domain/Projects/States/ProposedState.cs

 using PSManagement.Domain.Projects.ValueObjects;
+using System;
 
 namespace PSManagement.Domain.Projects.Entities
 {
@@ -11,7 +12,7 @@ namespace PSManagement.Domain.Projects.Entities
 
         }
 
-        public void Cancle(Project project)
+        public void Cancel(Project project, DateTime canellationTime)
         {
         
         }

PSManagement.Infrastructure.Persistence/EntitiesConfiguration/CustomerEntityConfiguration.cs

@@ -19,11 +19,10 @@ namespace PSManagement.Infrastructure.Persistence.EntitiesConfiguration
                 address.Property(a => a.StreetName).HasColumnName("StreetName");
                 address.Property(a => a.City).HasColumnName("City");
                 address.Property(a => a.StreetNumber).HasColumnName("StreetNumber");
-                address.Property(a => a.ZipCode).HasColumnName("ZipCode");
             }
             );
 
-            builder.OwnsMany(c => c.ContactInfo);
+            builder.HasMany(c => c.ContactInfo);
             
         }
     }

PSManagement.Infrastructure.Persistence/EntitiesConfiguration/ProjectEntityConfiguration.cs

@@ -37,6 +37,7 @@ namespace PSManagement.Infrastructure.Persistence.EntitiesConfiguration
 
                 }
             );
+            
             builder.HasOne(e => e.TeamLeader)
                .WithMany()
                .HasForeignKey(e => e.TeamLeaderId)
@@ -63,12 +64,17 @@ namespace PSManagement.Infrastructure.Persistence.EntitiesConfiguration
                     }
             );
 
-            builder.Property(p => p.CurrentState).HasDefaultValue("Proposed");
+            builder.Property(p => p.CurrentState)
+                .HasDefaultValueSql("Proposed")
+                ;
             
             builder.HasMany(e => e.Attachments).WithOne().HasForeignKey(e => e.ProjectId);
             builder.HasMany(e => e.FinancialSpending).WithOne().HasForeignKey(e=>e.ProjectId);
             builder.HasMany(e => e.Tracks).WithOne(e => e.Project).HasForeignKey(e => e.ProjectId);
             
         }
+
+
     }
+
 }

PSManagement.Infrastructure.Persistence/Migrations/20240817114741_FixCustomerEntity.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("20240817114741_FixCustomerEntity")]
+    partial class FixCustomerEntity
+    {
+        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.Entities.ContactInfo", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("ContactType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ContactValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CustomerId");
+
+                    b.ToTable("ContactInfo");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Customers.Entities.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.Employees.Entities.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");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            Name = "قسم المعلوميات"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            Name = "قسم النظم الإلكترونية"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            Name = "قسم الميكاترونيكس"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            Name = "قسم الفيزياء"
+                        },
+                        new
+                        {
+                            Id = 5,
+                            Name = "مديرية التطوير والخدمات البرمجية"
+                        },
+                        new
+                        {
+                            Id = 6,
+                            Name = "شؤون الطلاب"
+                        });
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Employees.Entities.Employee", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int>("DepartmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("HIASTId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DepartmentId");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("Employees");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.FinancialSpends.Entities.FinancialSpending", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("CostType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("ExpectedSpendingDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("LocalPurchase")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProjectId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("FinancialSpendings");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Identity.Entities.Permission", 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("Permission");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Identity.Entities.Role", 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("Roles");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            Name = "Admin"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            Name = "Employee"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            Name = "Scientific-Deputy"
+                        });
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Identity.Entities.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("HashedPassword")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 2,
+                            Email = "Admin@Admin",
+                            HashedPassword = "1234",
+                            UserName = "Admin"
+                        });
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.Attachment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("AttachmentDescription")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AttachmentName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AttachmentUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ProjectId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Attachment");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.EmployeeParticipate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PartialTimeRatio")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProjectId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Role")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("EmployeeParticipate");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.Project", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("CurrentState")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("nvarchar(max)")
+                        .HasDefaultValue("Proposed");
+
+                    b.Property<int?>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ExecuterId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProjectManagerId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProposerId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TeamLeaderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("ExecuterId");
+
+                    b.HasIndex("ProjectManagerId");
+
+                    b.HasIndex("ProposerId");
+
+                    b.HasIndex("TeamLeaderId");
+
+                    b.ToTable("Projects");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.Step", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int>("CurrentCompletionRatio")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProjectId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Weight")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Steps");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.Answer", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("AnswerValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("QuestionId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ReportResultId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("QuestionId");
+
+                    b.HasIndex("ReportResultId");
+
+                    b.ToTable("Answer");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.Question", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("QuestionName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Question");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.Report", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("ReportName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Reports");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.ReportResult", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int?>("ReportId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("ReportResults");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.Section", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int?>("ReportId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SectionName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("Section");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.EmployeeTrack", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int>("EmloyeeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Notes")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("TrackId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmloyeeId");
+
+                    b.HasIndex("TrackId");
+
+                    b.ToTable("EmployeeTrack");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Entities.StepTrack", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int>("ExecutionRatio")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ExecutionState")
+                        .HasColumnType("nvarchar(max)");
+
+                    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<string>("Notes")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ProjectId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Tracks");
+                });
+
+            modelBuilder.Entity("PermissionRole", b =>
+                {
+                    b.Property<int>("PermissionsId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RolesId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PermissionsId", "RolesId");
+
+                    b.HasIndex("RolesId");
+
+                    b.ToTable("PermissionRole");
+                });
+
+            modelBuilder.Entity("QuestionSection", b =>
+                {
+                    b.Property<int>("QuestionsId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SectionsId")
+                        .HasColumnType("int");
+
+                    b.HasKey("QuestionsId", "SectionsId");
+
+                    b.HasIndex("SectionsId");
+
+                    b.ToTable("QuestionSection");
+                });
+
+            modelBuilder.Entity("UserRole", b =>
+                {
+                    b.Property<int>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RoleId", "UserId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserRole");
+
+                    b.HasData(
+                        new
+                        {
+                            RoleId = 1,
+                            UserId = 1
+                        });
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Customers.Entities.ContactInfo", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Customers.Entities.Customer", null)
+                        .WithMany("ContactInfo")
+                        .HasForeignKey("CustomerId");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Customers.Entities.Customer", b =>
+                {
+                    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.HasKey("CustomerId");
+
+                            b1.ToTable("Customers");
+
+                            b1.WithOwner()
+                                .HasForeignKey("CustomerId");
+                        });
+
+                    b.Navigation("Address");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Employees.Entities.Employee", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Employees.Entities.Department", "Department")
+                        .WithMany()
+                        .HasForeignKey("DepartmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("PSManagement.Domain.Identity.Entities.User", "User")
+                        .WithOne("Employee")
+                        .HasForeignKey("PSManagement.Domain.Employees.Entities.Employee", "UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("PSManagement.Domain.Employees.Entities.Availability", "Availability", b1 =>
+                        {
+                            b1.Property<int>("EmployeeId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<int>("CurrentWorkingHours")
+                                .HasColumnType("int")
+                                .HasColumnName("CurrentWorkingHours");
+
+                            b1.Property<bool>("IsAvailable")
+                                .HasColumnType("bit")
+                                .HasColumnName("IsAvailable");
+
+                            b1.HasKey("EmployeeId");
+
+                            b1.ToTable("Employees");
+
+                            b1.WithOwner()
+                                .HasForeignKey("EmployeeId");
+                        });
+
+                    b.OwnsOne("PSManagement.Domain.Employees.Entities.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.OwnsOne("PSManagement.Domain.Employees.Entities.WorkInfo", "WorkInfo", b1 =>
+                        {
+                            b1.Property<int>("EmployeeId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("WorkJob")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("WorkJob");
+
+                            b1.Property<string>("WorkType")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("WorkType");
+
+                            b1.HasKey("EmployeeId");
+
+                            b1.ToTable("Employees");
+
+                            b1.WithOwner()
+                                .HasForeignKey("EmployeeId");
+                        });
+
+                    b.Navigation("Availability");
+
+                    b.Navigation("Department");
+
+                    b.Navigation("PersonalInfo");
+
+                    b.Navigation("User");
+
+                    b.Navigation("WorkInfo");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.FinancialSpends.Entities.FinancialSpending", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Projects.Entities.Project", null)
+                        .WithMany("FinancialSpending")
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("PSManagement.SharedKernel.ValueObjects.Money", "ExternalPurchase", b1 =>
+                        {
+                            b1.Property<int>("FinancialSpendingId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<int>("Ammount")
+                                .HasColumnType("int")
+                                .HasColumnName("ExternalPurchaseAmmount");
+
+                            b1.Property<string>("Currency")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("nvarchar(max)")
+                                .HasDefaultValue("USD")
+                                .HasColumnName("ExternalPurchaseCurrency");
+
+                            b1.HasKey("FinancialSpendingId");
+
+                            b1.ToTable("FinancialSpendings");
+
+                            b1.WithOwner()
+                                .HasForeignKey("FinancialSpendingId");
+                        });
+
+                    b.Navigation("ExternalPurchase");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.Attachment", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Projects.Entities.Project", null)
+                        .WithMany("Attachments")
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.EmployeeParticipate", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Employees.Entities.Employee", "Employee")
+                        .WithMany("EmployeeParticipates")
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PSManagement.Domain.Projects.Entities.Project", "Project")
+                        .WithMany("EmployeeParticipates")
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.Project", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Customers.Entities.Customer", null)
+                        .WithMany("Projects")
+                        .HasForeignKey("CustomerId");
+
+                    b.HasOne("PSManagement.Domain.Employees.Entities.Department", "Executer")
+                        .WithMany()
+                        .HasForeignKey("ExecuterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PSManagement.Domain.Employees.Entities.Employee", "ProjectManager")
+                        .WithMany()
+                        .HasForeignKey("ProjectManagerId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("PSManagement.Domain.Customers.Entities.Customer", "Proposer")
+                        .WithMany()
+                        .HasForeignKey("ProposerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PSManagement.Domain.Employees.Entities.Employee", "TeamLeader")
+                        .WithMany()
+                        .HasForeignKey("TeamLeaderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.OwnsOne("PSManagement.Domain.Projects.ValueObjects.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.ValueObjects.FinancialFund", "FinancialFund", b1 =>
+                        {
+                            b1.Property<int>("ProjectId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("FinancialStatus")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("FinicialStatus");
+
+                            b1.Property<string>("Source")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("FinicialSource");
+
+                            b1.HasKey("ProjectId");
+
+                            b1.ToTable("Projects");
+
+                            b1.WithOwner()
+                                .HasForeignKey("ProjectId");
+                        });
+
+                    b.OwnsOne("PSManagement.Domain.Projects.ValueObjects.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<DateTime>("ExpectedEndDate")
+                                .HasColumnType("datetime2")
+                                .HasColumnName("ExpectedEndDate");
+
+                            b1.Property<string>("Name")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("Name");
+
+                            b1.Property<DateTime>("StartDate")
+                                .HasColumnType("datetime2")
+                                .HasColumnName("StartDate");
+
+                            b1.HasKey("ProjectId");
+
+                            b1.ToTable("Projects");
+
+                            b1.WithOwner()
+                                .HasForeignKey("ProjectId");
+                        });
+
+                    b.OwnsOne("PSManagement.Domain.Projects.ValueObjects.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("FinancialFund");
+
+                    b.Navigation("ProjectAggreement");
+
+                    b.Navigation("ProjectInfo");
+
+                    b.Navigation("ProjectManager");
+
+                    b.Navigation("ProposalInfo");
+
+                    b.Navigation("Proposer");
+
+                    b.Navigation("TeamLeader");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.Step", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Projects.Entities.Project", "Project")
+                        .WithMany("Steps")
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("PSManagement.Domain.Projects.ValueObjects.StepInfo", "StepInfo", b1 =>
+                        {
+                            b1.Property<int>("StepId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("Description")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("Description");
+
+                            b1.Property<int>("Duration")
+                                .HasColumnType("int")
+                                .HasColumnName("Duration");
+
+                            b1.Property<DateTime>("StartDate")
+                                .HasColumnType("datetime2")
+                                .HasColumnName("StartDate");
+
+                            b1.Property<string>("StepName")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("StepName");
+
+                            b1.HasKey("StepId");
+
+                            b1.ToTable("Steps");
+
+                            b1.WithOwner()
+                                .HasForeignKey("StepId");
+                        });
+
+                    b.Navigation("Project");
+
+                    b.Navigation("StepInfo");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.Answer", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Reports.Entities.Question", "Question")
+                        .WithMany()
+                        .HasForeignKey("QuestionId");
+
+                    b.HasOne("PSManagement.Domain.Reports.Entities.ReportResult", null)
+                        .WithMany("Answers")
+                        .HasForeignKey("ReportResultId");
+
+                    b.Navigation("Question");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.ReportResult", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Reports.Entities.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId");
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.Section", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Reports.Entities.Report", "Report")
+                        .WithMany("Sections")
+                        .HasForeignKey("ReportId");
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.EmployeeTrack", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Employees.Entities.Employee", "Employee")
+                        .WithMany("EmployeeTracks")
+                        .HasForeignKey("EmloyeeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PSManagement.Domain.Tracking.Track", "Track")
+                        .WithMany("EmployeeTracks")
+                        .HasForeignKey("TrackId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("PSManagement.Domain.Tracking.ValueObjects.EmployeeWork", "EmployeeWork", b1 =>
+                        {
+                            b1.Property<int>("EmployeeTrackId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<int>("AssignedWorkingHours")
+                                .HasColumnType("int")
+                                .HasColumnName("AssignedWorkingHours");
+
+                            b1.Property<int>("ContributingRatio")
+                                .HasColumnType("int")
+                                .HasColumnName("ContributingRatio");
+
+                            b1.Property<int>("WorkedHours")
+                                .HasColumnType("int")
+                                .HasColumnName("WorkedHours");
+
+                            b1.HasKey("EmployeeTrackId");
+
+                            b1.ToTable("EmployeeTrack");
+
+                            b1.WithOwner()
+                                .HasForeignKey("EmployeeTrackId");
+                        });
+
+                    b.OwnsOne("PSManagement.Domain.Tracking.ValueObjects.EmployeeWorkInfo", "EmployeeWorkInfo", b1 =>
+                        {
+                            b1.Property<int>("EmployeeTrackId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("AssignedWork")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("AssignedWork");
+
+                            b1.Property<DateTime>("AssignedWorkEnd")
+                                .HasColumnType("datetime2")
+                                .HasColumnName("AssignedWorkEnd");
+
+                            b1.Property<string>("PerformedWork")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("PerformedWork");
+
+                            b1.HasKey("EmployeeTrackId");
+
+                            b1.ToTable("EmployeeTrack");
+
+                            b1.WithOwner()
+                                .HasForeignKey("EmployeeTrackId");
+                        });
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("EmployeeWork");
+
+                    b.Navigation("EmployeeWorkInfo");
+
+                    b.Navigation("Track");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Entities.StepTrack", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Projects.Entities.Step", "Step")
+                        .WithMany("StepTracks")
+                        .HasForeignKey("StepId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PSManagement.Domain.Tracking.Track", "Track")
+                        .WithMany("StepTracks")
+                        .HasForeignKey("TrackId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Step");
+
+                    b.Navigation("Track");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Track", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Projects.Entities.Project", "Project")
+                        .WithMany("Tracks")
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.OwnsOne("PSManagement.Domain.Tracking.ValueObjects.TrackInfo", "TrackInfo", b1 =>
+                        {
+                            b1.Property<int>("TrackId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<bool>("IsCompleted")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("bit")
+                                .HasDefaultValue(false)
+                                .HasColumnName("IsCompleted");
+
+                            b1.Property<string>("StatusDescription")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("StatusDescription");
+
+                            b1.Property<DateTime>("TrackDate")
+                                .HasColumnType("datetime2")
+                                .HasColumnName("TrackDate");
+
+                            b1.HasKey("TrackId");
+
+                            b1.ToTable("Tracks");
+
+                            b1.WithOwner()
+                                .HasForeignKey("TrackId");
+                        });
+
+                    b.Navigation("Project");
+
+                    b.Navigation("TrackInfo");
+                });
+
+            modelBuilder.Entity("PermissionRole", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Identity.Entities.Permission", null)
+                        .WithMany()
+                        .HasForeignKey("PermissionsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PSManagement.Domain.Identity.Entities.Role", null)
+                        .WithMany()
+                        .HasForeignKey("RolesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("QuestionSection", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Reports.Entities.Question", null)
+                        .WithMany()
+                        .HasForeignKey("QuestionsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PSManagement.Domain.Reports.Entities.Section", null)
+                        .WithMany()
+                        .HasForeignKey("SectionsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("UserRole", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Identity.Entities.Role", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PSManagement.Domain.Identity.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Customers.Entities.Customer", b =>
+                {
+                    b.Navigation("ContactInfo");
+
+                    b.Navigation("Projects");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Employees.Entities.Employee", b =>
+                {
+                    b.Navigation("EmployeeParticipates");
+
+                    b.Navigation("EmployeeTracks");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Identity.Entities.User", b =>
+                {
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.Project", b =>
+                {
+                    b.Navigation("Attachments");
+
+                    b.Navigation("EmployeeParticipates");
+
+                    b.Navigation("FinancialSpending");
+
+                    b.Navigation("Steps");
+
+                    b.Navigation("Tracks");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.Step", b =>
+                {
+                    b.Navigation("StepTracks");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.Report", b =>
+                {
+                    b.Navigation("Sections");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.ReportResult", b =>
+                {
+                    b.Navigation("Answers");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Track", b =>
+                {
+                    b.Navigation("EmployeeTracks");
+
+                    b.Navigation("StepTracks");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

PSManagement.Infrastructure.Persistence/Migrations/20240817114741_FixCustomerEntity.cs

+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace PSManagement.Infrastructure.Persistence.Migrations
+{
+    public partial class FixCustomerEntity : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_ContactInfo_Customers_CustomerId",
+                table: "ContactInfo");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_ContactInfo",
+                table: "ContactInfo");
+
+            migrationBuilder.DropColumn(
+                name: "ZipCode",
+                table: "Customers");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "CustomerId",
+                table: "ContactInfo",
+                type: "int",
+                nullable: true,
+                oldClrType: typeof(int),
+                oldType: "int");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_ContactInfo",
+                table: "ContactInfo",
+                column: "Id");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ContactInfo_CustomerId",
+                table: "ContactInfo",
+                column: "CustomerId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_ContactInfo_Customers_CustomerId",
+                table: "ContactInfo",
+                column: "CustomerId",
+                principalTable: "Customers",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Restrict);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_ContactInfo_Customers_CustomerId",
+                table: "ContactInfo");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_ContactInfo",
+                table: "ContactInfo");
+
+            migrationBuilder.DropIndex(
+                name: "IX_ContactInfo_CustomerId",
+                table: "ContactInfo");
+
+            migrationBuilder.AddColumn<int>(
+                name: "ZipCode",
+                table: "Customers",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AlterColumn<int>(
+                name: "CustomerId",
+                table: "ContactInfo",
+                type: "int",
+                nullable: false,
+                defaultValue: 0,
+                oldClrType: typeof(int),
+                oldType: "int",
+                oldNullable: true);
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_ContactInfo",
+                table: "ContactInfo",
+                columns: new[] { "CustomerId", "Id" });
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_ContactInfo_Customers_CustomerId",
+                table: "ContactInfo",
+                column: "CustomerId",
+                principalTable: "Customers",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+    }
+}

PSManagement.Infrastructure.Persistence/Migrations/20240817134029_FixProjectEntity.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("20240817134029_FixProjectEntity")]
+    partial class FixProjectEntity
+    {
+        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.Entities.ContactInfo", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("ContactType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ContactValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CustomerId");
+
+                    b.ToTable("ContactInfo");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Customers.Entities.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.Employees.Entities.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");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            Name = "قسم المعلوميات"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            Name = "قسم النظم الإلكترونية"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            Name = "قسم الميكاترونيكس"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            Name = "قسم الفيزياء"
+                        },
+                        new
+                        {
+                            Id = 5,
+                            Name = "مديرية التطوير والخدمات البرمجية"
+                        },
+                        new
+                        {
+                            Id = 6,
+                            Name = "شؤون الطلاب"
+                        });
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Employees.Entities.Employee", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int>("DepartmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("HIASTId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DepartmentId");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("Employees");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.FinancialSpends.Entities.FinancialSpending", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("CostType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("ExpectedSpendingDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("LocalPurchase")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProjectId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("FinancialSpendings");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Identity.Entities.Permission", 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("Permission");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Identity.Entities.Role", 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("Roles");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            Name = "Admin"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            Name = "Employee"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            Name = "Scientific-Deputy"
+                        });
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Identity.Entities.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("HashedPassword")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 2,
+                            Email = "Admin@Admin",
+                            HashedPassword = "1234",
+                            UserName = "Admin"
+                        });
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.Attachment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("AttachmentDescription")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AttachmentName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AttachmentUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ProjectId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Attachment");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.EmployeeParticipate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PartialTimeRatio")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProjectId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Role")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("EmployeeParticipate");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.Project", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("CurrentState")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("nvarchar(max)")
+                        .HasDefaultValueSql("Proposed");
+
+                    b.Property<int?>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ExecuterId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProjectManagerId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProposerId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TeamLeaderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("ExecuterId");
+
+                    b.HasIndex("ProjectManagerId");
+
+                    b.HasIndex("ProposerId");
+
+                    b.HasIndex("TeamLeaderId");
+
+                    b.ToTable("Projects");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.Step", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int>("CurrentCompletionRatio")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProjectId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Weight")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Steps");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.Answer", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("AnswerValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("QuestionId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ReportResultId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("QuestionId");
+
+                    b.HasIndex("ReportResultId");
+
+                    b.ToTable("Answer");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.Question", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("QuestionName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Question");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.Report", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("ReportName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Reports");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.ReportResult", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int?>("ReportId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("ReportResults");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.Section", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int?>("ReportId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SectionName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("Section");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.EmployeeTrack", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int>("EmloyeeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Notes")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("TrackId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmloyeeId");
+
+                    b.HasIndex("TrackId");
+
+                    b.ToTable("EmployeeTrack");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Entities.StepTrack", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int>("ExecutionRatio")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ExecutionState")
+                        .HasColumnType("nvarchar(max)");
+
+                    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<string>("Notes")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ProjectId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Tracks");
+                });
+
+            modelBuilder.Entity("PermissionRole", b =>
+                {
+                    b.Property<int>("PermissionsId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RolesId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PermissionsId", "RolesId");
+
+                    b.HasIndex("RolesId");
+
+                    b.ToTable("PermissionRole");
+                });
+
+            modelBuilder.Entity("QuestionSection", b =>
+                {
+                    b.Property<int>("QuestionsId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SectionsId")
+                        .HasColumnType("int");
+
+                    b.HasKey("QuestionsId", "SectionsId");
+
+                    b.HasIndex("SectionsId");
+
+                    b.ToTable("QuestionSection");
+                });
+
+            modelBuilder.Entity("UserRole", b =>
+                {
+                    b.Property<int>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RoleId", "UserId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserRole");
+
+                    b.HasData(
+                        new
+                        {
+                            RoleId = 1,
+                            UserId = 1
+                        });
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Customers.Entities.ContactInfo", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Customers.Entities.Customer", null)
+                        .WithMany("ContactInfo")
+                        .HasForeignKey("CustomerId");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Customers.Entities.Customer", b =>
+                {
+                    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.HasKey("CustomerId");
+
+                            b1.ToTable("Customers");
+
+                            b1.WithOwner()
+                                .HasForeignKey("CustomerId");
+                        });
+
+                    b.Navigation("Address");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Employees.Entities.Employee", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Employees.Entities.Department", "Department")
+                        .WithMany()
+                        .HasForeignKey("DepartmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("PSManagement.Domain.Identity.Entities.User", "User")
+                        .WithOne("Employee")
+                        .HasForeignKey("PSManagement.Domain.Employees.Entities.Employee", "UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("PSManagement.Domain.Employees.Entities.Availability", "Availability", b1 =>
+                        {
+                            b1.Property<int>("EmployeeId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<int>("CurrentWorkingHours")
+                                .HasColumnType("int")
+                                .HasColumnName("CurrentWorkingHours");
+
+                            b1.Property<bool>("IsAvailable")
+                                .HasColumnType("bit")
+                                .HasColumnName("IsAvailable");
+
+                            b1.HasKey("EmployeeId");
+
+                            b1.ToTable("Employees");
+
+                            b1.WithOwner()
+                                .HasForeignKey("EmployeeId");
+                        });
+
+                    b.OwnsOne("PSManagement.Domain.Employees.Entities.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.OwnsOne("PSManagement.Domain.Employees.Entities.WorkInfo", "WorkInfo", b1 =>
+                        {
+                            b1.Property<int>("EmployeeId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("WorkJob")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("WorkJob");
+
+                            b1.Property<string>("WorkType")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("WorkType");
+
+                            b1.HasKey("EmployeeId");
+
+                            b1.ToTable("Employees");
+
+                            b1.WithOwner()
+                                .HasForeignKey("EmployeeId");
+                        });
+
+                    b.Navigation("Availability");
+
+                    b.Navigation("Department");
+
+                    b.Navigation("PersonalInfo");
+
+                    b.Navigation("User");
+
+                    b.Navigation("WorkInfo");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.FinancialSpends.Entities.FinancialSpending", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Projects.Entities.Project", null)
+                        .WithMany("FinancialSpending")
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("PSManagement.SharedKernel.ValueObjects.Money", "ExternalPurchase", b1 =>
+                        {
+                            b1.Property<int>("FinancialSpendingId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<int>("Ammount")
+                                .HasColumnType("int")
+                                .HasColumnName("ExternalPurchaseAmmount");
+
+                            b1.Property<string>("Currency")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("nvarchar(max)")
+                                .HasDefaultValue("USD")
+                                .HasColumnName("ExternalPurchaseCurrency");
+
+                            b1.HasKey("FinancialSpendingId");
+
+                            b1.ToTable("FinancialSpendings");
+
+                            b1.WithOwner()
+                                .HasForeignKey("FinancialSpendingId");
+                        });
+
+                    b.Navigation("ExternalPurchase");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.Attachment", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Projects.Entities.Project", null)
+                        .WithMany("Attachments")
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.EmployeeParticipate", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Employees.Entities.Employee", "Employee")
+                        .WithMany("EmployeeParticipates")
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PSManagement.Domain.Projects.Entities.Project", "Project")
+                        .WithMany("EmployeeParticipates")
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.Project", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Customers.Entities.Customer", null)
+                        .WithMany("Projects")
+                        .HasForeignKey("CustomerId");
+
+                    b.HasOne("PSManagement.Domain.Employees.Entities.Department", "Executer")
+                        .WithMany()
+                        .HasForeignKey("ExecuterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PSManagement.Domain.Employees.Entities.Employee", "ProjectManager")
+                        .WithMany()
+                        .HasForeignKey("ProjectManagerId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("PSManagement.Domain.Customers.Entities.Customer", "Proposer")
+                        .WithMany()
+                        .HasForeignKey("ProposerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PSManagement.Domain.Employees.Entities.Employee", "TeamLeader")
+                        .WithMany()
+                        .HasForeignKey("TeamLeaderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.OwnsOne("PSManagement.Domain.Projects.ValueObjects.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.ValueObjects.FinancialFund", "FinancialFund", b1 =>
+                        {
+                            b1.Property<int>("ProjectId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("FinancialStatus")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("FinicialStatus");
+
+                            b1.Property<string>("Source")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("FinicialSource");
+
+                            b1.HasKey("ProjectId");
+
+                            b1.ToTable("Projects");
+
+                            b1.WithOwner()
+                                .HasForeignKey("ProjectId");
+                        });
+
+                    b.OwnsOne("PSManagement.Domain.Projects.ValueObjects.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<DateTime>("ExpectedEndDate")
+                                .HasColumnType("datetime2")
+                                .HasColumnName("ExpectedEndDate");
+
+                            b1.Property<string>("Name")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("Name");
+
+                            b1.Property<DateTime>("StartDate")
+                                .HasColumnType("datetime2")
+                                .HasColumnName("StartDate");
+
+                            b1.HasKey("ProjectId");
+
+                            b1.ToTable("Projects");
+
+                            b1.WithOwner()
+                                .HasForeignKey("ProjectId");
+                        });
+
+                    b.OwnsOne("PSManagement.Domain.Projects.ValueObjects.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("FinancialFund");
+
+                    b.Navigation("ProjectAggreement");
+
+                    b.Navigation("ProjectInfo");
+
+                    b.Navigation("ProjectManager");
+
+                    b.Navigation("ProposalInfo");
+
+                    b.Navigation("Proposer");
+
+                    b.Navigation("TeamLeader");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.Step", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Projects.Entities.Project", "Project")
+                        .WithMany("Steps")
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("PSManagement.Domain.Projects.ValueObjects.StepInfo", "StepInfo", b1 =>
+                        {
+                            b1.Property<int>("StepId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("Description")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("Description");
+
+                            b1.Property<int>("Duration")
+                                .HasColumnType("int")
+                                .HasColumnName("Duration");
+
+                            b1.Property<DateTime>("StartDate")
+                                .HasColumnType("datetime2")
+                                .HasColumnName("StartDate");
+
+                            b1.Property<string>("StepName")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("StepName");
+
+                            b1.HasKey("StepId");
+
+                            b1.ToTable("Steps");
+
+                            b1.WithOwner()
+                                .HasForeignKey("StepId");
+                        });
+
+                    b.Navigation("Project");
+
+                    b.Navigation("StepInfo");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.Answer", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Reports.Entities.Question", "Question")
+                        .WithMany()
+                        .HasForeignKey("QuestionId");
+
+                    b.HasOne("PSManagement.Domain.Reports.Entities.ReportResult", null)
+                        .WithMany("Answers")
+                        .HasForeignKey("ReportResultId");
+
+                    b.Navigation("Question");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.ReportResult", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Reports.Entities.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId");
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.Section", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Reports.Entities.Report", "Report")
+                        .WithMany("Sections")
+                        .HasForeignKey("ReportId");
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.EmployeeTrack", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Employees.Entities.Employee", "Employee")
+                        .WithMany("EmployeeTracks")
+                        .HasForeignKey("EmloyeeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PSManagement.Domain.Tracking.Track", "Track")
+                        .WithMany("EmployeeTracks")
+                        .HasForeignKey("TrackId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("PSManagement.Domain.Tracking.ValueObjects.EmployeeWork", "EmployeeWork", b1 =>
+                        {
+                            b1.Property<int>("EmployeeTrackId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<int>("AssignedWorkingHours")
+                                .HasColumnType("int")
+                                .HasColumnName("AssignedWorkingHours");
+
+                            b1.Property<int>("ContributingRatio")
+                                .HasColumnType("int")
+                                .HasColumnName("ContributingRatio");
+
+                            b1.Property<int>("WorkedHours")
+                                .HasColumnType("int")
+                                .HasColumnName("WorkedHours");
+
+                            b1.HasKey("EmployeeTrackId");
+
+                            b1.ToTable("EmployeeTrack");
+
+                            b1.WithOwner()
+                                .HasForeignKey("EmployeeTrackId");
+                        });
+
+                    b.OwnsOne("PSManagement.Domain.Tracking.ValueObjects.EmployeeWorkInfo", "EmployeeWorkInfo", b1 =>
+                        {
+                            b1.Property<int>("EmployeeTrackId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("AssignedWork")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("AssignedWork");
+
+                            b1.Property<DateTime>("AssignedWorkEnd")
+                                .HasColumnType("datetime2")
+                                .HasColumnName("AssignedWorkEnd");
+
+                            b1.Property<string>("PerformedWork")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("PerformedWork");
+
+                            b1.HasKey("EmployeeTrackId");
+
+                            b1.ToTable("EmployeeTrack");
+
+                            b1.WithOwner()
+                                .HasForeignKey("EmployeeTrackId");
+                        });
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("EmployeeWork");
+
+                    b.Navigation("EmployeeWorkInfo");
+
+                    b.Navigation("Track");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Entities.StepTrack", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Projects.Entities.Step", "Step")
+                        .WithMany("StepTracks")
+                        .HasForeignKey("StepId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PSManagement.Domain.Tracking.Track", "Track")
+                        .WithMany("StepTracks")
+                        .HasForeignKey("TrackId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Step");
+
+                    b.Navigation("Track");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Track", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Projects.Entities.Project", "Project")
+                        .WithMany("Tracks")
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.OwnsOne("PSManagement.Domain.Tracking.ValueObjects.TrackInfo", "TrackInfo", b1 =>
+                        {
+                            b1.Property<int>("TrackId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<bool>("IsCompleted")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("bit")
+                                .HasDefaultValue(false)
+                                .HasColumnName("IsCompleted");
+
+                            b1.Property<string>("StatusDescription")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("StatusDescription");
+
+                            b1.Property<DateTime>("TrackDate")
+                                .HasColumnType("datetime2")
+                                .HasColumnName("TrackDate");
+
+                            b1.HasKey("TrackId");
+
+                            b1.ToTable("Tracks");
+
+                            b1.WithOwner()
+                                .HasForeignKey("TrackId");
+                        });
+
+                    b.Navigation("Project");
+
+                    b.Navigation("TrackInfo");
+                });
+
+            modelBuilder.Entity("PermissionRole", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Identity.Entities.Permission", null)
+                        .WithMany()
+                        .HasForeignKey("PermissionsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PSManagement.Domain.Identity.Entities.Role", null)
+                        .WithMany()
+                        .HasForeignKey("RolesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("QuestionSection", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Reports.Entities.Question", null)
+                        .WithMany()
+                        .HasForeignKey("QuestionsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PSManagement.Domain.Reports.Entities.Section", null)
+                        .WithMany()
+                        .HasForeignKey("SectionsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("UserRole", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Identity.Entities.Role", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PSManagement.Domain.Identity.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Customers.Entities.Customer", b =>
+                {
+                    b.Navigation("ContactInfo");
+
+                    b.Navigation("Projects");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Employees.Entities.Employee", b =>
+                {
+                    b.Navigation("EmployeeParticipates");
+
+                    b.Navigation("EmployeeTracks");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Identity.Entities.User", b =>
+                {
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.Project", b =>
+                {
+                    b.Navigation("Attachments");
+
+                    b.Navigation("EmployeeParticipates");
+
+                    b.Navigation("FinancialSpending");
+
+                    b.Navigation("Steps");
+
+                    b.Navigation("Tracks");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.Step", b =>
+                {
+                    b.Navigation("StepTracks");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.Report", b =>
+                {
+                    b.Navigation("Sections");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.ReportResult", b =>
+                {
+                    b.Navigation("Answers");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Track", b =>
+                {
+                    b.Navigation("EmployeeTracks");
+
+                    b.Navigation("StepTracks");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

PSManagement.Infrastructure.Persistence/Migrations/20240817134029_FixProjectEntity.cs

+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace PSManagement.Infrastructure.Persistence.Migrations
+{
+    public partial class FixProjectEntity : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<string>(
+                name: "CurrentState",
+                table: "Projects",
+                type: "nvarchar(max)",
+                nullable: true,
+                defaultValueSql: "Proposed",
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)",
+                oldNullable: true,
+                oldDefaultValue: "Proposed");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<string>(
+                name: "CurrentState",
+                table: "Projects",
+                type: "nvarchar(max)",
+                nullable: true,
+                defaultValue: "Proposed",
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)",
+                oldNullable: true,
+                oldDefaultValueSql: "Proposed");
+        }
+    }
+}

PSManagement.Infrastructure.Persistence/Migrations/AppDbContextModelSnapshot.cs

@@ -20,6 +20,29 @@ namespace PSManagement.Infrastructure.Persistence.Migrations
                 .HasAnnotation("ProductVersion", "5.0.17")
                 .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
 
+            modelBuilder.Entity("PSManagement.Domain.Customers.Entities.ContactInfo", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("ContactType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ContactValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CustomerId");
+
+                    b.ToTable("ContactInfo");
+                });
+
             modelBuilder.Entity("PSManagement.Domain.Customers.Entities.Customer", b =>
                 {
                     b.Property<int>("Id")
@@ -281,7 +304,7 @@ namespace PSManagement.Infrastructure.Persistence.Migrations
                     b.Property<string>("CurrentState")
                         .ValueGeneratedOnAdd()
                         .HasColumnType("nvarchar(max)")
-                        .HasDefaultValue("Proposed");
+                        .HasDefaultValueSql("Proposed");
 
                     b.Property<int?>("CustomerId")
                         .HasColumnType("int");
@@ -553,32 +576,15 @@ namespace PSManagement.Infrastructure.Persistence.Migrations
                         });
                 });
 
-            modelBuilder.Entity("PSManagement.Domain.Customers.Entities.Customer", b =>
+            modelBuilder.Entity("PSManagement.Domain.Customers.Entities.ContactInfo", 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()
+                    b.HasOne("PSManagement.Domain.Customers.Entities.Customer", null)
+                        .WithMany("ContactInfo")
                         .HasForeignKey("CustomerId");
                 });
 
+            modelBuilder.Entity("PSManagement.Domain.Customers.Entities.Customer", b =>
+                {
                     b.OwnsOne("PSManagement.Domain.Customers.ValueObjects.Address", "Address", b1 =>
                         {
                             b1.Property<int>("CustomerId")
@@ -598,10 +604,6 @@ namespace PSManagement.Infrastructure.Persistence.Migrations
                                 .HasColumnType("int")
                                 .HasColumnName("StreetNumber");
 
-                            b1.Property<int>("ZipCode")
-                                .HasColumnType("int")
-                                .HasColumnName("ZipCode");
-
                             b1.HasKey("CustomerId");
 
                             b1.ToTable("Customers");
@@ -611,8 +613,6 @@ namespace PSManagement.Infrastructure.Persistence.Migrations
                         });
 
                     b.Navigation("Address");
-
-                    b.Navigation("ContactInfo");
                 });
 
             modelBuilder.Entity("PSManagement.Domain.Employees.Entities.Employee", b =>
@@ -1181,6 +1181,8 @@ namespace PSManagement.Infrastructure.Persistence.Migrations
 
             modelBuilder.Entity("PSManagement.Domain.Customers.Entities.Customer", b =>
                 {
+                    b.Navigation("ContactInfo");
+
                     b.Navigation("Projects");
                 });