fix state transitions

PSManagement.Api/Controllers/Projects/ProjectsController.cs

@@ -23,6 +23,7 @@ using PSManagement.Application.Projects.UseCases.Commands.CompleteProgressProjec
 using PSManagement.Application.Projects.UseCases.Commands.CompletePlaningProject;
 using PSManagement.Application.Contracts.Providers;
 using PSManagement.Application.Projects.UseCases.Commands.CancelProject;
+using PSManagement.Application.Projects.UseCases.Commands.ChangeProjectManager;
 
 namespace PSManagement.Api.Controllers.Projects
 {
@@ -98,6 +99,16 @@ namespace PSManagement.Api.Controllers.Projects
             return HandleResult(result);
         }
 
+        [HttpPut("ChangeProjectManager")]
+        public async Task<IActionResult> PutProjectManager(ChangeProjectManagerRequest request)
+        {
+            var query = _mapper.Map<ChangeProjectManagerCommand>(request);
+
+            var result = await _sender.Send(query);
+
+            return HandleResult(result);
+        }
+
 
         [HttpPost("AddProjectStep")]
         public async Task<IActionResult> PostAddParticipant(AddProjectStepRequest request)
@@ -161,6 +172,16 @@ namespace PSManagement.Api.Controllers.Projects
             return BadRequest();
         }
 
+        [HttpPost("RePlanProject")]
+        public async Task<IActionResult> PostCompleteProjectRequest(RePlanProjectRequest request)
+        {
+            var query = _mapper.Map<RePlanProjectCommand>(request);
+
+            var result = await _sender.Send(query);
+
+            return HandleResult(result);
+        }
+
         [HttpPost("CompleteProject/{id}")]
         public async Task<IActionResult> PostCompleteProjectRequest(int id )
         {
@@ -197,7 +218,7 @@ namespace PSManagement.Api.Controllers.Projects
                 var query = new GetProjectByIdQuery(result.Value);
                 var response = await _sender.Send(query);
 
-                return HandleResult(_mapper.Map<Result<ProjectResponse>>(response));
+                return HandleResult(_mapper.Map<Result<ProjectDetailsResponse>>(response));
 
             }
             else {

PSManagement.Application/ApplicationDTOsMappers/MapperConfiguration.cs

@@ -68,9 +68,10 @@ namespace PSManagement.Application.Mappers
            
             
             CreateMap<Project, ProjectDTO>().ReverseMap();
+            CreateMap<Project, ProjectDetailsDTO>().ReverseMap();
 
 
-            CreateMap <CreateFinancialSpendItemCommand,FinancialSpending> ()
+            CreateMap<CreateFinancialSpendItemCommand,FinancialSpending> ()
                 .ForMember(d=>d.Id, op => op.Ignore())
                 .ForMember(d=> d.Events, op => op.Ignore())
                 .ConstructUsing(src => new FinancialSpending(

PSManagement.Application/PSManagement.Application.csproj

@@ -8,6 +8,7 @@
   <ItemGroup>
     <Folder Include="Behaviors\AuthorizationBehavior\" />
     <Folder Include="Projects\UseCases\Commands\ChangeParticipantPartialTime\" />
+    <Folder Include="Tracks\UseCaes\Queries\GetUncompletedTracks\" />
   </ItemGroup>
 
   <ItemGroup>

PSManagement.Application/Projects/Common/ProjectDTO.cs

@@ -13,6 +13,7 @@ namespace PSManagement.Application.Projects.Common
     {
         public int Id { get; set; }
         public ProposalInfo ProposalInfo { get; set; }
+        public ProjectClassification ProjectClassification { get; set; }
         public ProjectInfo ProjectInfo { get; set; }
         public string CurrentState { get; set; }
         public Aggreement ProjectAggreement { get; set; }

PSManagement.Application/Projects/Common/ProjectDetailsDTO.cs

+using PSManagement.Application.Employees.Common;
+using PSManagement.Domain.Customers.Entities;
+using PSManagement.Domain.Employees.Entities;
+using PSManagement.Domain.Projects.ValueObjects;
+
+namespace PSManagement.Application.Projects.Common
+{
+    public class ProjectDetailsDTO
+    {
+        public int Id { get; set; }
+        public ProposalInfo ProposalInfo { get; set; }
+        public ProjectInfo ProjectInfo { get; set; }
+        public string CurrentState { get; set; }
+        public Aggreement ProjectAggreement { get; set; }
+        public ProjectClassification ProjectClassification { get; set; }
+        public EmployeeDTO TeamLeader { get; set; }
+        public EmployeeDTO ProjectManager { get; set; }
+        public Department Executer { get; set; }
+        public Customer Proposer { get; set; }
+        public FinancialFund FinancialFund { get; set; }
+        
+        public ProjectDetailsDTO()
+        {
+
+        }
+    }
+}
\ No newline at end of file

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

@@ -49,7 +49,7 @@ namespace PSManagement.Application.Projects.UseCases.Commands.AddParticipant
                 return Result.Invalid(ProjectsErrors.InvalidEntryError);
             }else {
 
-                if (project.EmployeeParticipates.Where(e => e.EmployeeId == request.ParticipantId).FirstOrDefault() is not  null)
+                if (project.HasParticipant(request.ParticipantId))
                 {
 
                     return Result.Invalid(ProjectsErrors.ParticipantExistError);
@@ -63,9 +63,8 @@ namespace PSManagement.Application.Projects.UseCases.Commands.AddParticipant
 
                     }
 
-                    await _employeeParticipateRepository.AddAsync(new (request.ParticipantId,request.ProjectId,request.Role,request.PartialTimeRatio));
-                    
-                    project.AddDomainEvent(new ParticipantAddedEvent(request.ParticipantId,request.ProjectId,request.PartialTimeRatio,request.Role));
+                    // this method encapsulate the event publishig 
+                    project.AddParticipation(request.ParticipantId, request.ProjectId, request.Role, request.PartialTimeRatio);
 
                     await _unitOfWork.SaveChangesAsync();
                     return Result.Success();

PSManagement.Application/Projects/UseCases/Commands/ApproveProject/ApproveProjectCommand.cs

@@ -9,7 +9,6 @@ using System.Text;
 namespace PSManagement.Application.Projects.UseCases.Commands.ApproveProject
 {
     public record ApproveProjectCommand(
-        Aggreement ProjectAggreement,
         int ProjectId
         ): ICommand<Result>;
 

PSManagement.Application/Projects/UseCases/Commands/ApproveProject/ApproveProjectCommandHandler.cs

 using Ardalis.Result;
+using PSManagement.Domain.Projects;
 using PSManagement.Domain.Projects.DomainErrors;
 using PSManagement.Domain.Projects.Entities;
 using PSManagement.Domain.Projects.Repositories;
 using PSManagement.SharedKernel.CQRS.Command;
 using PSManagement.SharedKernel.Interfaces;
+using PSManagement.SharedKernel.Specification;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -13,6 +15,7 @@ namespace PSManagement.Application.Projects.UseCases.Commands.ApproveProject
     {
         private readonly IProjectsRepository _projectsRepository;
         private readonly IUnitOfWork _unitOfWork;
+        private readonly BaseSpecification<Project> _specification;
 
         public ApproveProjectCommandHandler(
             IProjectsRepository projectsRepository,
@@ -22,24 +25,36 @@ namespace PSManagement.Application.Projects.UseCases.Commands.ApproveProject
 
             _projectsRepository = projectsRepository;
             _unitOfWork = unitOfWork;
-            
+            _specification = new ProjectSpecification();
         }
 
         public async Task<Result> Handle(ApproveProjectCommand request, CancellationToken cancellationToken)
         {
+            _specification.AddInclude(e => e.Steps);
+
             Project project = await _projectsRepository.GetByIdAsync(request.ProjectId);
+            
             if (project is null)
             {
                 return Result.Invalid(ProjectsErrors.InvalidEntryError);
             }
             else
             {
-
-                Result result =project.Approve(request.ProjectAggreement);
+                if (project.VailedSteps())
+                {
+                    Result result = project.Approve();
                     await _unitOfWork.SaveChangesAsync();
-
                     return result;
 
+                }
+                else {
+
+                    return Result.Invalid(ProjectsErrors.InvalidStepWeight);
+                    
+                }
+
+
+
 
 
             }

PSManagement.Application/Projects/UseCases/Commands/ChangeProjectManager/ChangeProjectManagerCommand.cs

+using Ardalis.Result;
+using PSManagement.SharedKernel.CQRS.Command;
+
+namespace PSManagement.Application.Projects.UseCases.Commands.ChangeProjectManager
+{
+    public record ChangeProjectManagerCommand(
+    int EmployeeId,
+    int ProjectId
+) : ICommand<Result>;
+
+}

PSManagement.Application/Projects/UseCases/Commands/ChangeProjectManager/ChangeProjectManagerCommandHandler.cs

+using Ardalis.Result;
+using PSManagement.Domain.Employees.DomainErrors;
+using PSManagement.Domain.Employees.Entities;
+using PSManagement.Domain.Employees.Repositories;
+using PSManagement.Domain.Projects.DomainErrors;
+using PSManagement.Domain.Projects.Entities;
+using PSManagement.Domain.Projects.Repositories;
+using PSManagement.SharedKernel.CQRS.Command;
+using PSManagement.SharedKernel.Interfaces;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace PSManagement.Application.Projects.UseCases.Commands.ChangeProjectManager
+{
+    public class ChangeProjectManagerCommandHandler : ICommandHandler<ChangeProjectManagerCommand, Result>
+    {
+        private readonly IProjectsRepository _projectsRepository;
+        private readonly IEmployeesRepository _employeesRepository;
+
+        private readonly IUnitOfWork _unitOfWork;
+
+        public ChangeProjectManagerCommandHandler(
+            IProjectsRepository projectsRepository,
+            IUnitOfWork unitOfWork,
+            IEmployeesRepository employeesRepository)
+        {
+
+            _projectsRepository = projectsRepository;
+            _unitOfWork = unitOfWork;
+            _employeesRepository = employeesRepository;
+        }
+
+        public async Task<Result> Handle(ChangeProjectManagerCommand request, CancellationToken cancellationToken)
+        {
+            Project project = await _projectsRepository.GetByIdAsync(request.ProjectId);
+            if (project is null)
+            {
+                return Result.Invalid(ProjectsErrors.InvalidEntryError);
+            }
+            else
+            {
+                Employee teamLeader = await _employeesRepository.GetByIdAsync(request.EmployeeId);
+                if (teamLeader is null)
+                {
+                    return Result.Invalid(EmployeesErrors.EmployeeUnExist);
+                }
+                project.TeamLeader = teamLeader;
+                project.TeamLeaderId = request.EmployeeId;
+                await _projectsRepository.UpdateAsync(project);
+
+                await _unitOfWork.SaveChangesAsync();
+
+                return Result.Success();
+
+
+
+            }
+        }
+    }
+
+}

PSManagement.Application/Projects/UseCases/Commands/CreateProject/CreateProjectCommand.cs

@@ -14,6 +14,7 @@ namespace PSManagement.Application.Projects.UseCases.Commands.CreateProject
         ProposalInfo ProposalInfo,
         Aggreement ProjectAggreement,
         FinancialFund FinancialFund,
+        ProjectClassification ProjectClassification,
         int TeamLeaderId ,
         int ProjectManagerId,
         int ProposerId,

PSManagement.Application/Projects/UseCases/Commands/CreateProject/CreateProjectCommandHandler.cs

@@ -39,6 +39,7 @@ namespace PSManagement.Application.Projects.UseCases.Commands.CreateProject
                 .WithProjectManager(request.ProjectManagerId)
                 .WithTeamLeader(request.TeamLeaderId)
                 .WithProposer(request.ProposerId)
+                .WithClassification(request.ProjectClassification)
                 .Build();
             
             project.Propose();

PSManagement.Application/Projects/UseCases/Commands/CompletePlaningProject/CompletePlaningProjectCommand.cs → PSManagement.Application/Projects/UseCases/Commands/RePlanProject/RePlanProjectCommand.cs

@@ -3,7 +3,7 @@ using PSManagement.SharedKernel.CQRS.Command;
 
 namespace PSManagement.Application.Projects.UseCases.Commands.CompletePlaningProject
 {
-    public record CompletePlaningProjectCommand(
+    public record RePlanProjectCommand(
         int ProjectId
         ) : ICommand<Result>;
 

PSManagement.Application/Projects/UseCases/Commands/CompletePlaningProject/CompletePlaningProjectCommandHandler.cs → PSManagement.Application/Projects/UseCases/Commands/RePlanProject/RePlanProjectCommandHandler.cs

@@ -9,12 +9,12 @@ using System.Threading.Tasks;
 
 namespace PSManagement.Application.Projects.UseCases.Commands.CompletePlaningProject
 {
-    public class CompletePlaningProjectCommandHandler : ICommandHandler<CompletePlaningProjectCommand, Result>
+    public class RePlanProjectCommandHandler : ICommandHandler<RePlanProjectCommand, Result>
     {
         private readonly IProjectsRepository _projectsRepository;
         private readonly IUnitOfWork _unitOfWork;
 
-        public CompletePlaningProjectCommandHandler(
+        public RePlanProjectCommandHandler(
             IProjectsRepository projectsRepository,
             IUnitOfWork unitOfWork
             )
@@ -25,7 +25,7 @@ namespace PSManagement.Application.Projects.UseCases.Commands.CompletePlaningPro
 
         }
 
-        public async Task<Result> Handle(CompletePlaningProjectCommand request, CancellationToken cancellationToken)
+        public async Task<Result> Handle(RePlanProjectCommand request, CancellationToken cancellationToken)
         {
             Project project = await _projectsRepository.GetByIdAsync(request.ProjectId);
             if (project is null)

PSManagement.Application/Projects/UseCases/Queries/GetProjectsByFilter/GetProjectsByFilterQuery.cs

@@ -14,6 +14,6 @@ namespace PSManagement.Application.Projects.UseCases.Queries.ListAllProject
          int? PageNumber,
          int? PageSize,
          string ProposerName
-     ) : IQuery<Result<IEnumerable<ProjectDTO>>>;
+     ) : IQuery<Result<IEnumerable<ProjectDetailsDTO>>>;
 
 }

PSManagement.Application/Projects/UseCases/Queries/GetProjectsByFilter/GetProjectsByFilterQueryHandler.cs

@@ -13,7 +13,7 @@ using System.Threading.Tasks;
 
 namespace PSManagement.Application.Projects.UseCases.Queries.ListAllProject
 {
-    public class GetProjectsByFilterQueryHandler : IQueryHandler<GetProjectsByFilterQuery, Result<IEnumerable<ProjectDTO>>>
+    public class GetProjectsByFilterQueryHandler : IQueryHandler<GetProjectsByFilterQuery, Result<IEnumerable<ProjectDetailsDTO>>>
     {
         private readonly IProjectsRepository _projectsRepository;
         private readonly IMapper _mapper;
@@ -29,7 +29,7 @@ namespace PSManagement.Application.Projects.UseCases.Queries.ListAllProject
 
         private readonly BaseSpecification<Project> _specification;
 
-        public async Task<Result<IEnumerable<ProjectDTO>>> Handle(GetProjectsByFilterQuery request, CancellationToken cancellationToken)
+        public async Task<Result<IEnumerable<ProjectDetailsDTO>>> Handle(GetProjectsByFilterQuery request, CancellationToken cancellationToken)
         {
             _specification.AddInclude(e => e.TeamLeader);
             _specification.AddInclude(e => e.Executer);
@@ -68,7 +68,7 @@ namespace PSManagement.Application.Projects.UseCases.Queries.ListAllProject
             {
                 projects = projects.Where(p => p.TeamLeaderId == request.TeamLeaderId);
             }
-            return Result.Success(_mapper.Map<IEnumerable<ProjectDTO>>(projects));
+            return Result.Success(_mapper.Map<IEnumerable<ProjectDetailsDTO>>(projects));
         }
     }
 

PSManagement.Application/Projects/UseCases/Queries/ListAllProject/ListAllProjectsQuery.cs

@@ -9,6 +9,6 @@ namespace PSManagement.Application.Projects.UseCases.Queries.ListAllProject
         int? PageNumber,
         int? PageSize
 
-        ) : IQuery<Result<IEnumerable<ProjectDTO>>>;
+        ) : IQuery<Result<IEnumerable<ProjectDetailsDTO>>>;
 
 }

PSManagement.Application/Projects/UseCases/Queries/ListAllProject/ListAllProjectsQueryHandler.cs

@@ -12,7 +12,7 @@ using System.Threading.Tasks;
 
 namespace PSManagement.Application.Projects.UseCases.Queries.ListAllProject
 {
-    public class ListAllProjectsQueryHandler : IQueryHandler<ListAllProjectsQuery, Result<IEnumerable<ProjectDTO>>>
+    public class ListAllProjectsQueryHandler : IQueryHandler<ListAllProjectsQuery, Result<IEnumerable<ProjectDetailsDTO>>>
     {
         private readonly IProjectsRepository _projectsRepository;
         private readonly BaseSpecification<Project> _specification;
@@ -27,10 +27,11 @@ namespace PSManagement.Application.Projects.UseCases.Queries.ListAllProject
             _mapper = mapper;
         }
 
-        public async Task<Result<IEnumerable<ProjectDTO>>> Handle(ListAllProjectsQuery request, CancellationToken cancellationToken)
+        public async Task<Result<IEnumerable<ProjectDetailsDTO>>> Handle(ListAllProjectsQuery request, CancellationToken cancellationToken)
         {
             int pageNumber=request.PageNumber.HasValue && request.PageNumber.Value > 0 ? request.PageNumber.Value : 1;
             int pageSize = request.PageSize.HasValue && request.PageSize.Value > 0 && request.PageSize.Value <= 30 ? request.PageSize.Value : 30;
+            
             _specification.AddInclude(e => e.ProjectManager);
             _specification.AddInclude(e => e.Proposer);
             _specification.AddInclude(e => e.TeamLeader);
@@ -42,7 +43,7 @@ namespace PSManagement.Application.Projects.UseCases.Queries.ListAllProject
 
             var projects = await _projectsRepository.ListAsync(_specification);
 
-            return Result.Success(_mapper.Map<IEnumerable<ProjectDTO>>(projects));    
+            return Result.Success(_mapper.Map<IEnumerable<ProjectDetailsDTO>>(projects));    
         }
     }
 

PSManagement.Contracts/Projects/Requests/ApproveProjectRequest.cs

@@ -3,7 +3,6 @@
 namespace PSManagement.Contracts.Projects.Requests
 {
     public record ApproveProjectRequest(
-    Aggreement ProjectAggreement,
     int ProjectId
     );
 

PSManagement.Contracts/Projects/Requests/ChangeProjectManagerRequest.cs

+namespace PSManagement.Contracts.Projects.Requests
+{
+    public record ChangeProjectManagerRequest(
+    int EmployeeId,
+    int ProjectId
+    );
+
+}

PSManagement.Contracts/Projects/Requests/CreateProjectRequest.cs

@@ -11,6 +11,7 @@ namespace PSManagement.Contracts.Projects.Requests
         ProposalInfo ProposalInfo,
         Aggreement ProjectAggreement,
         FinancialFund FinancialFund,
+        ProjectClassification ProjectClassification ,
         int TeamLeaderId,
         int ProjectManagerId,
         int ProposerId,

PSManagement.Contracts/Projects/Requests/RePlanProjectRequest.cs

+namespace PSManagement.Contracts.Projects.Requests
+{
+    public record RePlanProjectRequest (
+        int ProjectId
+        );
+}

PSManagement.Contracts/Projects/Response/ProjectDetailsResponse.cs

+using PSManagement.Contracts.Customers.Responses;
+using PSManagement.Domain.Employees.Entities;
+using PSManagement.Domain.Projects.ValueObjects;
+
+namespace PSManagement.Contracts.Projects.Response
+{
+    public class ProjectDetailsResponse
+    {
+        public int Id { get; set; }
+        public ProposalInfo ProposalInfo { get; set; }
+        public ProjectInfo ProjectInfo { get; set; }
+        public string CurrentState { get; set; }
+        public Aggreement ProjectAggreement { get; set; }
+        
+        public EmployeeResponse TeamLeader { get; set; }
+        public EmployeeResponse ProjectManager { get; set; }
+        public Department Executer { get; set; }
+
+        public CustomerResponse Proposer { get; set; }
+        
+        public FinancialFund FinancialFund { get; set; }
+        
+        
+    }
+
+}

PSManagement.Domain/Projects/Builders/ProjectBuilder.cs

@@ -24,12 +24,17 @@ namespace PSManagement.Domain.Projects.Builders
         private int _executerId;
         private int _proposerId;
         private string _stateName;
+        private ProjectClassification _projectClassification;
         private ICollection<Step> _steps;
         private ICollection<EmployeeParticipate> _participants;
         private ICollection<Attachment> _attachments;
 
         private ICollection<FinancialSpending> _financialSpending;
-
+        public ProjectBuilder WithClassification(ProjectClassification projectClassification)
+        {
+            _projectClassification = projectClassification;
+            return this;
+        }
         public ProjectBuilder WithParticipants(ICollection<EmployeeParticipate> participates)
         {
             _participants = participates;
@@ -114,7 +119,8 @@ namespace PSManagement.Domain.Projects.Builders
                 _teamLeaderId,
                 _projectManagerId ,
                 _executerId,
-                _stateName);
+                _stateName,
+                _projectClassification);
             project.FinancialFund = _financialFund;
 
             if (_attachments is not null) {

PSManagement.Domain/Projects/DomainErrors/ProjectsErrors.cs

@@ -13,6 +13,8 @@ namespace PSManagement.Domain.Projects.DomainErrors
         public static DomainError InvalidEntryError { get; } = new ("ProjectError.InvalidEntry.", "Invalid Project Data");
         public static DomainError ParticipantExistError { get; } = new("ProjectError.Participant.Exist.", "the Project already have the given particpant Data");
         public static DomainError ParticipantUnExistError { get; } = new("ProjectError.Participant.UnExist.", "the Project doesnt have the given particpant Data");
+        public static DomainError InvalidStepWeight { get; } = new("ProjectError.Step.InvaildWeight", "theStep Weigths has invalid sum");
+
         public static DomainError StateTracnsitionError (string from, string to) => new("ProjectError.StateTransitionError","you cannot change the project state from " +from +" to "+to); 
 
     }

PSManagement.Domain/Projects/Entities/Project.cs

@@ -2,6 +2,7 @@
 using PSManagement.Domain.Customers.Entities;
 using PSManagement.Domain.Employees.Entities;
 using PSManagement.Domain.FinancialSpends.Entities;
+using PSManagement.Domain.Projects.DomainEvents;
 using PSManagement.Domain.Projects.ValueObjects;
 using PSManagement.Domain.Tracking;
 using PSManagement.SharedKernel.Aggregate;
@@ -24,7 +25,7 @@ namespace PSManagement.Domain.Projects.Entities
         public ProposalInfo ProposalInfo { get; set; }
         public ProjectInfo ProjectInfo { get; set; }
         public Aggreement ProjectAggreement { get; set; }
-
+        public ProjectClassification ProjectClassification { get; set; }
         #endregion Project  informations
 
         #region Project State 
@@ -47,6 +48,8 @@ namespace PSManagement.Domain.Projects.Entities
             set => _state = value;
         }
 
+
+
         #endregion Project State
 
         // information about who lead and execute the project 
@@ -85,6 +88,15 @@ namespace PSManagement.Domain.Projects.Entities
             Attachments.Add(attachment);
 
         }
+
+        public void AddParticipation(int participantId, int projectId, string role, int partialTimeRatio)
+        {
+            this.EmployeeParticipates.Add(new (participantId,projectId,role, partialTimeRatio));
+
+            AddDomainEvent(new ParticipantAddedEvent(participantId, projectId,partialTimeRatio, role));
+
+        }
+
         public void AddAttachment(string attachmentUrl,string attachmentName,string attachmentDescription,int projectId)
         {
             Attachment attachment = new(attachmentUrl, attachmentName,attachmentDescription, projectId);
@@ -117,9 +129,9 @@ namespace PSManagement.Domain.Projects.Entities
             return State.Plan(this);
 
         }
-        public Result Approve(Aggreement projectAggreement)
+        public Result Approve()
         {
-            return State.Approve(this, projectAggreement);
+            return State.Approve(this);
 
         }
         public Result Cancel(DateTime canellationTime)
@@ -132,8 +144,28 @@ namespace PSManagement.Domain.Projects.Entities
             return State.Propose(this);
 
         }
+        public void SetState(IProjectState newState)
+        {
+            _state = newState;
+            CurrentState = _state.StateName;
+        }
 
         #endregion State Transitions
+        public bool VailedSteps()
+        {
+            int weightSum = 0;
+            foreach (Step step in Steps) {
+                weightSum += step.Weight;
+            }
+            return weightSum == 100;
+
+        }
+        public bool HasParticipant(int participantId)
+        {
+            return EmployeeParticipates.Where(e => e.EmployeeId ==participantId).FirstOrDefault() is not null;
+        }
+
+        #region constructors 
         public Project(
             ProposalInfo proposalInfo,
             ProjectInfo projectInfo,
@@ -142,9 +174,11 @@ namespace PSManagement.Domain.Projects.Entities
             int teamLeaderId,
             int projectManagerId,
             int executerId,
-            string stateName
+            string stateName,
+            ProjectClassification projectClassification
             )
         {
+            ProjectClassification = projectClassification;
             SetStateFromString(stateName);
             ProposalInfo = proposalInfo;
             ProjectInfo = projectInfo;
@@ -166,11 +200,8 @@ namespace PSManagement.Domain.Projects.Entities
         {
         }
 
-        public void SetState(IProjectState newState)
-        {
-            _state = newState;
-            CurrentState = _state.StateName;
-        }
+        #endregion constructors 
+
         
         #region state extracting from state name 
         public void SetStateFromString(string stateName)

PSManagement.Domain/Projects/States/CancledState.cs

@@ -9,7 +9,7 @@ namespace PSManagement.Domain.Projects.Entities
     {
         public string StateName => "CancledState";
 
-        public Result Approve(Project project, Aggreement projectAggreement)
+        public Result Approve(Project project)
         {
             return Result.Invalid(ProjectsErrors.StateTracnsitionError("Cancelled","Approved"));
         }

PSManagement.Domain/Projects/States/CompletedState.cs

@@ -9,30 +9,30 @@ namespace PSManagement.Domain.Projects.Entities
     {
         public string StateName => "Completed";
 
-        public Result Approve(Project project, Aggreement projectAggreement)
+        public Result Approve(Project project)
         {
-            return Result.Invalid(ProjectsErrors.StateTracnsitionError("Approved", "Approved"));
+            return Result.Invalid(ProjectsErrors.StateTracnsitionError("Completed", "Approved"));
         }
 
         public Result Cancel(Project project, DateTime canellationTime)
         {
-            return Result.Invalid(ProjectsErrors.StateTracnsitionError("Approved", "Cancelled"));
+            return Result.Invalid(ProjectsErrors.StateTracnsitionError("Completed", "Cancelled"));
         }
 
         public Result Complete(Project project)
         {
-            return Result.Invalid(ProjectsErrors.StateTracnsitionError("Approved", "Completed"));
+            return Result.Invalid(ProjectsErrors.StateTracnsitionError("Completed", "Completed"));
         }
 
         public Result Plan(Project project)
         {
-            return Result.Invalid(ProjectsErrors.StateTracnsitionError("Approved", "InPlan"));
+            return Result.Invalid(ProjectsErrors.StateTracnsitionError("Completed", "InPlan"));
 
         }
 
         public Result Propose(Project project)
         {
-            return Result.Invalid(ProjectsErrors.StateTracnsitionError("Approved", "Proposed"));
+            return Result.Invalid(ProjectsErrors.StateTracnsitionError("Completed", "Proposed"));
 
         }
     }

PSManagement.Domain/Projects/States/IProjectState.cs

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

PSManagement.Domain/Projects/States/InPlanState.cs

@@ -10,11 +10,11 @@ namespace PSManagement.Domain.Projects.Entities
     {
         public string StateName => "InPlan";
 
-        public Result Approve(Project project, Aggreement projectAggreement)
+        public Result Approve(Project project)
         {
 
-            project.ProjectAggreement = projectAggreement;
-            project.AddDomainEvent(new ProjectApprovedEvent(project.Id,projectAggreement));
+            project.AddDomainEvent(new ProjectApprovedEvent(project.Id,project.ProjectAggreement));
+
             project.SetState(new InProgressState());
             return Result.Success();
         }
@@ -41,7 +41,7 @@ namespace PSManagement.Domain.Projects.Entities
 
         public Result Propose(Project project)
         {
-            return Result.Invalid(ProjectsErrors.StateTracnsitionError("Approved", "Proposed"));
+            return Result.Invalid(ProjectsErrors.StateTracnsitionError("In Planning", "Proposed"));
 
         }
     }

PSManagement.Domain/Projects/States/InProgressState.cs

@@ -10,7 +10,7 @@ namespace PSManagement.Domain.Projects.Entities
     {
         public string StateName => "InProgress";
 
-        public Result Approve(Project project, Aggreement projectAggreement)
+        public Result Approve(Project project)
         {
             return Result.Invalid(ProjectsErrors.StateTracnsitionError("InProgress", "Approved"));
 

PSManagement.Domain/Projects/States/ProposedState.cs

@@ -10,7 +10,7 @@ namespace PSManagement.Domain.Projects.Entities
     {
         public string StateName => "Proposed";
 
-        public Result Approve(Project project, Aggreement projectAggreement)
+        public Result Approve(Project project)
         {
             return Result.Invalid(ProjectsErrors.StateTracnsitionError("Proposed", "Approved"));
 

PSManagement.Domain/Projects/ValueObjects/ProjectClassification.cs

+namespace PSManagement.Domain.Projects.ValueObjects
+{
+    public record ProjectClassification(
+        string ProjectNature,
+        string ProjectStatus,
+        string ProjectType
+        );
+
+}

PSManagement.Infrastructure.Persistence/EntitiesConfiguration/ProjectEntityConfiguration.cs

@@ -26,6 +26,14 @@ namespace PSManagement.Infrastructure.Persistence.EntitiesConfiguration
                     p.Property(e => e.AggreementNumber).HasColumnName("AggreementNumber");
                 }
             );
+            builder.OwnsOne(c => c.ProjectClassification,
+                p => {
+                    p.Property(e => e.ProjectNature).HasColumnName("ProjectNature");
+                    p.Property(e => e.ProjectStatus).HasColumnName("ProjectStatus");
+                    p.Property(e => e.ProjectType).HasColumnName("ProjectType");
+                }
+            );
+
             builder.OwnsOne(c => c.ProjectInfo,
                 p => {
                     p.Property(e => e.Description).HasColumnName("Description");

PSManagement.Infrastructure.Persistence/Migrations/20240821095456_AdddProjectClassification.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("20240821095456_AdddProjectClassification")]
+    partial class AdddProjectClassification
+    {
+        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<string>("ExecutionState")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("OldExecutionRatio")
+                        .HasColumnType("int");
+
+                    b.Property<int>("StepId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TrackExecutionRatio")
+                        .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.ProjectClassification", "ProjectClassification", b1 =>
+                        {
+                            b1.Property<int>("ProjectId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("ProjectNature")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("ProjectNature");
+
+                            b1.Property<string>("ProjectStatus")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("ProjectStatus");
+
+                            b1.Property<string>("ProjectType")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("ProjectType");
+
+                            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("ProjectClassification");
+
+                    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/20240821095456_AdddProjectClassification.cs

+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace PSManagement.Infrastructure.Persistence.Migrations
+{
+    public partial class AdddProjectClassification : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "ProjectNature",
+                table: "Projects",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "ProjectStatus",
+                table: "Projects",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "ProjectType",
+                table: "Projects",
+                type: "nvarchar(max)",
+                nullable: true);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "ProjectNature",
+                table: "Projects");
+
+            migrationBuilder.DropColumn(
+                name: "ProjectStatus",
+                table: "Projects");
+
+            migrationBuilder.DropColumn(
+                name: "ProjectType",
+                table: "Projects");
+        }
+    }
+}

PSManagement.Infrastructure.Persistence/Migrations/AppDbContextModelSnapshot.cs

@@ -849,6 +849,33 @@ namespace PSManagement.Infrastructure.Persistence.Migrations
                                 .HasForeignKey("ProjectId");
                         });
 
+                    b.OwnsOne("PSManagement.Domain.Projects.ValueObjects.ProjectClassification", "ProjectClassification", b1 =>
+                        {
+                            b1.Property<int>("ProjectId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("ProjectNature")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("ProjectNature");
+
+                            b1.Property<string>("ProjectStatus")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("ProjectStatus");
+
+                            b1.Property<string>("ProjectType")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("ProjectType");
+
+                            b1.HasKey("ProjectId");
+
+                            b1.ToTable("Projects");
+
+                            b1.WithOwner()
+                                .HasForeignKey("ProjectId");
+                        });
+
                     b.OwnsOne("PSManagement.Domain.Projects.ValueObjects.ProjectInfo", "ProjectInfo", b1 =>
                         {
                             b1.Property<int>("ProjectId")
@@ -913,6 +940,8 @@ namespace PSManagement.Infrastructure.Persistence.Migrations
 
                     b.Navigation("ProjectAggreement");
 
+                    b.Navigation("ProjectClassification");
+
                     b.Navigation("ProjectInfo");
 
                     b.Navigation("ProjectManager");

PSManagement.Presentation/PSManagement.Presentation.csproj

@@ -15,4 +15,8 @@
     <ProjectReference Include="..\PSManagement.Contracts\PSManagement.Contracts.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Folder Include="Controllers\" />
+  </ItemGroup>
+
 </Project>