Implement CQRS for project domain

PSManagement.Application/ApplicationDTOsMappers/CustomerMapperConfiguration.cs → PSManagement.Application/ApplicationDTOsMappers/MapperConfiguration.cs

 using AutoMapper;
 using PSManagement.Application.Customers.Common;
+using PSManagement.Application.Employees.Common;
+using PSManagement.Application.FinancialSpends.Common;
+using PSManagement.Application.Projects.Common;
+using PSManagement.Application.Tracks.Common;
 using PSManagement.Domain.Customers.Entities;
 using PSManagement.Domain.Customers.ValueObjects;
+using PSManagement.Domain.Employees.Entities;
+using PSManagement.Domain.FinancialSpends.Entities;
+using PSManagement.Domain.Projects.Entities;
+using PSManagement.Domain.Tracking;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -10,13 +18,24 @@ using System.Threading.Tasks;
 
 namespace PSManagement.Application.Mappers
 {
-    class CustomerMapperConfiguration :Profile
+    class MapperConfiguration :Profile
     {
-        public CustomerMapperConfiguration()
+        public MapperConfiguration()
         {
             CreateMap<CustomerDTO, Customer>().ReverseMap();
             CreateMap<ContactInfoDTO, ContactInfo>().ReverseMap();
 
+            CreateMap<StepDTO, Step>().ReverseMap();
+
+            CreateMap<EmployeeDTO, Employee>().ReverseMap();
+            CreateMap<EmployeeParticipateDTO, EmployeeParticipate>().ReverseMap();
+
+            CreateMap<TrackDTO, Track>().ReverseMap();
+            CreateMap<FinancialSpendingDTO, FinancialSpending>().ReverseMap();
+            CreateMap<Project, ProjectDTO>()
+                      .ReverseMap(); // This allows for mapping in the reverse direction as well
+
         }
     }
+
 }

PSManagement.Application/DI/DependencyInjection.cs

@@ -26,7 +26,7 @@ namespace PSManagement.Application.DI
             services.AddValidatorsFromAssembly(Assembly.GetExecutingAssembly());
 
             
-            services.AddAutoMapper(typeof(CustomerMapperConfiguration));
+            services.AddAutoMapper(typeof(Mappers.MapperConfiguration));
 
             return services;
         }

PSManagement.Application/Employees/Common/EmployeeDTO.cs

+using PSManagement.Domain.Employees.Entities;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PSManagement.Application.Employees.Common
+{
+    public class EmployeeDTO
+    {
+        public int Id { get; set; }
+        public int HIASTId { get; set; }
+        public int UserId { get; set; }
+        public PersonalInfo PersonalInfo { get; set; }
+        public WorkInfo WorkInfo { get; set; }
+
+    }
+}

PSManagement.Application/FinancialSpends/Common/FinancialSpendingDTO.cs

+using PSManagement.SharedKernel.ValueObjects;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PSManagement.Application.FinancialSpends.Common
+{
+    public class FinancialSpendingDTO
+    {
+        public int Id { get; set; }
+        public DateTime ExpectedSpendingDate { get; set; }
+        public string CostType { get; set; }
+        public string Description { get; set; }
+        public int LocalPurchase { get; set; }
+        public Money ExternalPurchase { get; set; }
+    }
+}

PSManagement.Application/PSManagement.Application.csproj

@@ -2,42 +2,29 @@
 
   <PropertyGroup>
     <TargetFramework>net5.0</TargetFramework>
-	  <NoWarn>NU1701</NoWarn>
+	  <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
   </PropertyGroup>
 
   <ItemGroup>
     <Folder Include="Behaviors\AuthorizationBehavior\" />
+    <Folder Include="Behaviors\LoggingBehavior\" />
     <Folder Include="Employees\UseCases\Commands\UpdateEmployeeWorkHours\" />
     <Folder Include="Employees\UseCases\Commands\SyncEmployeesData\" />
     <Folder Include="Employees\UseCases\Queries\GetEmployeeWorkingHours\" />
     <Folder Include="Employees\UseCases\Queries\GetEmployeeProjects\" />
     <Folder Include="Employees\UseCases\Queries\GetAvailableEmployees\" />
     <Folder Include="Employees\UseCases\Queries\GetEmployeeParticipations\" />
-    <Folder Include="FinancialSpending\UseCases\Commands\CreateFinancialSpendingItem\" />
-    <Folder Include="FinancialSpending\UseCases\Commands\" />
-    <Folder Include="FinancialSpending\UseCases\Commands\UpateFinancialSpendingItem\" />
-    <Folder Include="FinancialSpending\UseCases\Queries\GetFinancialSpendingByProject\" />
-    <Folder Include="FinancialSpending\UseCases\Queries\GetFinancialSpendingById\" />
-    <Folder Include="Projects\UseCases\Commands\AddProjectPlan\" />
-    <Folder Include="Projects\UseCases\Commands\AddParticipant\" />
-    <Folder Include="Projects\UseCases\Commands\ApproveProject\" />
-    <Folder Include="Projects\UseCases\Commands\ChangeProjectTeamLeader\" />
-    <Folder Include="Projects\UseCases\Commands\CompletePlanProcess\" />
-    <Folder Include="Projects\UseCases\Commands\CancleProject\" />
-    <Folder Include="Projects\UseCases\Commands\CompleteProgressProcess\" />
-    <Folder Include="Projects\UseCases\Commands\RemoveParticipant\" />
-    <Folder Include="Projects\UseCases\Commands\UpdateParticipant\" />
-    <Folder Include="Projects\UseCases\Commands\UpdateStep\" />
-    <Folder Include="Projects\UseCases\Queries\ListAllProject\" />
+    <Folder Include="FinancialSpends\UseCases\Commands\CreateFinancialSpendingItem\" />
+    <Folder Include="FinancialSpends\UseCases\Commands\" />
+    <Folder Include="FinancialSpends\UseCases\Commands\UpateFinancialSpendingItem\" />
+    <Folder Include="FinancialSpends\UseCases\Queries\GetFinancialSpendingByProject\" />
+    <Folder Include="FinancialSpends\UseCases\Queries\GetFinancialSpendingById\" />
     <Folder Include="Projects\UseCases\Queries\GetProjectPlan\" />
-    <Folder Include="Projects\UseCases\Queries\GetProject\" />
     <Folder Include="Projects\UseCases\Queries\GetProjectFinicialSpending\" />
-    <Folder Include="Projects\UseCases\Queries\GetParticipants\" />
-    <Folder Include="Reports\UseCases\" />
-    <Folder Include="Reports\UseCases\Queries\" />
+    <Folder Include="XReports\UseCases\" />
+    <Folder Include="XReports\UseCases\Queries\" />
     <Folder Include="Steps\UseCases\Commands\ChangeStepWeight\" />
     <Folder Include="Steps\UseCases\Commands\UpdateCompletionRatio\" />
-    <Folder Include="Steps\UseCases\Commands\UpdateStepRequiredWorkers\" />
     <Folder Include="Steps\UseCases\Commands\RemoveStep\" />
     <Folder Include="Steps\UseCases\Queries\GetStep\" />
     <Folder Include="Steps\UseCases\Queries\GetStepHistory\" />

PSManagement.Application/Projects/Common/EmployeeParticipateDTO.cs

+using PSManagement.Application.Employees.Common;
+
+namespace PSManagement.Application.Projects.Common
+{
+    public class EmployeeParticipateDTO
+    {
+        public int EmployeeId { get; set; }
+        public int ProjectId { get; set; }
+        public EmployeeDTO Employee { get; set; }
+        public int PartialTimeRatio { get; set; }
+        public string Role { get; set; }
+    }
+}
\ No newline at end of file

PSManagement.Application/Projects/Common/ProjectDTO.cs

-using PSManagement.Domain.Customers.Entities;
+using PSManagement.Application.Employees.Common;
+using PSManagement.Application.FinancialSpends.Common;
+using PSManagement.Domain.Customers.Entities;
 using PSManagement.Domain.Employees.Entities;
 using PSManagement.Domain.Projects.Entities;
 using PSManagement.Domain.Projects.ValueObjects;
 using PSManagement.Domain.ProjectsStatus.Entites;
+using System;
 using System.Collections.Generic;
 
 namespace PSManagement.Application.Projects.Common
@@ -12,33 +15,29 @@ namespace PSManagement.Application.Projects.Common
         public int Id { get; set; }
         public ProposalInfo ProposalInfo { get; set; }
         public ProjectInfo ProjectInfo { get; set; }
-        public ProjectStatus ProjectStatus { get; set; }
+        public string CurrentState { get; set; }
         public Aggreement ProjectAggreement { get; set; }
-
-        // information about who lead and execute the project 
         public int TeamLeaderId { get; set; }
-        public Employee TeamLeader { get; set; }
+
+        public EmployeeDTO TeamLeader { get; set; }
         public int ProjectManagerId { get; set; }
-        public Employee ProjectManager { get; set; }
+        public EmployeeDTO ProjectManager { get; set; }
         public int ExecuterId { get; set; }
         public Department Executer { get; set; }
 
-        // the proposer of the project 
         public int ProposerId { get; private set; }
         public Customer Proposer { get; set; }
-
-        // 
-        public ICollection<Step> Steps { get; set; }
-        public ICollection<Employee> Participants { get; set; }
+        public ICollection<StepDTO> Steps { get; set; }
         public ICollection<Attachment> Attachments { get; set; }
 
-        // finincial plan 
         public FinancialFund FinancialFund { get; set; }
-        public ICollection<FinancialSpending> FinancialSpending { get; set; }
-
+        public ICollection<FinancialSpendingDTO> FinancialSpending { get; set; }
 
+        public ICollection<EmployeeParticipateDTO> EmployeeParticipates { get; set; }
 
-        public ICollection<EmployeeParticipate> EmployeeParticipates { get; set; }
+        public ProjectDTO()
+        {
 
+        }
     }
 }
\ No newline at end of file

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

+using Ardalis.Result;
+using PSManagement.SharedKernel.CQRS.Command;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+
+namespace PSManagement.Application.Projects.UseCases.Commands.AddParticipant
+{
+    public record  AddParticipantCommand(
+        int ProjectId,
+        int ParticipantId,
+        int PartialTimeRatio,
+        String Role 
+        ):ICommand<Result>;
+}

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

+using Ardalis.Result;
+using PSManagement.Application.Contracts.Email;
+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.Repositories;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Linq;
+using PSManagement.Domain.Projects.DomainEvents;
+using PSManagement.SharedKernel.Specification;
+using PSManagement.Domain.Projects;
+
+namespace PSManagement.Application.Projects.UseCases.Commands.AddParticipant
+{
+    public class AddParticipantCommandHandler : ICommandHandler<AddParticipantCommand, Result>
+    {
+        private readonly IProjectsRepository _projectsRepository;
+        private readonly IRepository<EmployeeParticipate> _employeeParticipateRepository;
+        private readonly IUnitOfWork _unitOfWork;
+        private readonly BaseSpecification<Project> _specification;
+
+        public AddParticipantCommandHandler(
+            IRepository<EmployeeParticipate> repository,
+            IProjectsRepository projectsRepository, 
+            IUnitOfWork unitOfWork)
+        {
+            _employeeParticipateRepository = repository;
+            _specification = new ProjectSpecification();
+            _projectsRepository = projectsRepository;
+            _unitOfWork = unitOfWork;
+        }
+
+        public async Task<Result> Handle(AddParticipantCommand request, CancellationToken cancellationToken)
+        {
+            _specification.Includes.Add(p => p.EmployeeParticipates);
+            Project project =await _projectsRepository.GetByIdAsync(request.ProjectId,_specification);
+            if (project is null)
+            {
+                return Result.Invalid(ProjectsErrors.InvalidEntryError);
+            }else {
+
+                if (project.EmployeeParticipates.Where(e => e.Id == request.ParticipantId).FirstOrDefault() is not  null)
+                {
+
+                    return Result.Invalid(ProjectsErrors.ParticipantExistError);
+                }
+                else {
+
+                    await _employeeParticipateRepository.AddAsync(new (request.ParticipantId,request.ProjectId,request.Role,request.PartialTimeRatio));
+                    project.AddDomainEvent(new ParticipantAddedEvent(request.ParticipantId,request.ProjectId,request.PartialTimeRatio,request.Role));
+
+                    await _unitOfWork.SaveChangesAsync();
+                    return Result.Success();
+                }
+            
+            
+            }
+        }
+    }
+
+}

PSManagement.Application/Projects/UseCases/Commands/AddProjectStep/AddProjectStepCommand.cs

+using Ardalis.Result;
+using PSManagement.Domain.Projects.ValueObjects;
+using PSManagement.SharedKernel.CQRS.Command;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace PSManagement.Application.Projects.UseCases.Commands.AddProjectStep
+{
+    public record AddProjectStepCommand(
+        int ProjectId,
+        StepInfo StepInfo,
+        int CurrentCompletionRatio,
+        int Weight
+        ):ICommand<Result<int>>;
+
+}

PSManagement.Application/Projects/UseCases/Commands/AddProjectStep/AddProjectStepCommandHandler.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;
+
+namespace PSManagement.Application.Projects.UseCases.Commands.AddProjectStep
+{
+    public class AddProjectStepCommandHandler : ICommandHandler<AddProjectStepCommand, Result<int>>
+    {
+        private readonly IProjectsRepository _projectsRepository;
+        private readonly IStepsRepository _stepsRepository;
+        private readonly IUnitOfWork _unitOfWork;
+        private readonly BaseSpecification<Project> _specification;
+
+        public AddProjectStepCommandHandler(
+            IProjectsRepository projectsRepository,
+            IUnitOfWork unitOfWork,
+            IStepsRepository stepsRepository)
+        {
+
+            _projectsRepository = projectsRepository;
+            _unitOfWork = unitOfWork;
+            _specification = new ProjectSpecification();
+           
+            _stepsRepository = stepsRepository;
+        }
+
+        public async Task<Result<int>> Handle(AddProjectStepCommand request, CancellationToken cancellationToken)
+        {
+            Project project = await _projectsRepository.GetByIdAsync(request.ProjectId,_specification);
+            if (project is null)
+            {
+                return Result.Invalid(ProjectsErrors.InvalidEntryError);
+            }
+            else
+            {    
+                Step  step = await _stepsRepository.AddAsync(new(request.StepInfo ,request.ProjectId,request.Weight));
+                
+                await _unitOfWork.SaveChangesAsync();
+                
+                return Result.Success(step.Id);
+                
+
+
+            }
+        }
+    }
+
+}

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

+using Ardalis.Result;
+using PSManagement.Domain.Projects.ValueObjects;
+using PSManagement.SharedKernel.CQRS.Command;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+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.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.ApproveProject
+{
+    public class ApproveProjectCommandHandler : ICommandHandler<ApproveProjectCommand, Result>
+    {
+        private readonly IProjectsRepository _projectsRepository;
+        private readonly IUnitOfWork _unitOfWork;
+        
+        public ApproveProjectCommandHandler(
+            IProjectsRepository projectsRepository,
+            IUnitOfWork unitOfWork
+            )
+        {
+
+            _projectsRepository = projectsRepository;
+            _unitOfWork = unitOfWork;
+            
+        }
+
+        public async Task<Result> Handle(ApproveProjectCommand request, CancellationToken cancellationToken)
+        {
+            Project project = await _projectsRepository.GetByIdAsync(request.ProjectId);
+            if (project is null)
+            {
+                return Result.Invalid(ProjectsErrors.InvalidEntryError);
+            }
+            else
+            {
+
+                project.Approve(request.ProjectAggreement);
+                await _unitOfWork.SaveChangesAsync();
+
+                return Result.Success();
+
+
+
+            }
+        }
+    }
+
+}

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

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

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

+using Ardalis.Result;
+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.CancelProject
+{
+    public class CancelProjectCommandHandler : ICommandHandler<CancelProjectCommand, Result>
+    {
+        private readonly IProjectsRepository _projectsRepository;
+        private readonly IUnitOfWork _unitOfWork;
+
+        public CancelProjectCommandHandler(
+            IProjectsRepository projectsRepository,
+            IUnitOfWork unitOfWork
+            )
+        {
+
+            _projectsRepository = projectsRepository;
+            _unitOfWork = unitOfWork;
+
+        }
+
+        public async Task<Result> Handle(CancelProjectCommand request, CancellationToken cancellationToken)
+        {
+            Project project = await _projectsRepository.GetByIdAsync(request.ProjectId);
+            if (project is null)
+            {
+                return Result.Invalid(ProjectsErrors.InvalidEntryError);
+            }
+            else
+            {
+
+                project.Cancle();
+                await _unitOfWork.SaveChangesAsync();
+
+                return Result.Success();
+
+
+
+            }
+        }
+    }
+
+}

PSManagement.Application/Projects/UseCases/Commands/ChangeProjectTeamLeader/ChangeProjectTeamLeaderCommand.cs

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

PSManagement.Application/Projects/UseCases/Commands/ChangeProjectTeamLeader/ChangeProjectTeamLeaderCommandHandler.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.ChangeProjectTeamLeader
+{
+    public class ChangeProjectTeamLeaderCommandHandler : ICommandHandler<ChangeProjectTeamLeaderCommand, Result>
+    {
+        private readonly IProjectsRepository _projectsRepository;
+        private readonly IEmployeesRepository _employeesRepository;
+
+        private readonly IUnitOfWork _unitOfWork;
+
+        public ChangeProjectTeamLeaderCommandHandler(
+            IProjectsRepository projectsRepository,
+            IUnitOfWork unitOfWork,
+            IEmployeesRepository employeesRepository)
+        {
+
+            _projectsRepository = projectsRepository;
+            _unitOfWork = unitOfWork;
+            _employeesRepository = employeesRepository;
+        }
+
+        public async Task<Result> Handle(ChangeProjectTeamLeaderCommand 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/CompletePlaningProject/CompletePlaningProjectCommand.cs

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

PSManagement.Application/Projects/UseCases/Commands/CompletePlaningProject/CompletePlaningProjectCommandHandler.cs

+using Ardalis.Result;
+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.CompletePlaningProject
+{
+    public class CompletePlaningProjectCommandHandler : ICommandHandler<CompletePlaningProjectCommand, Result>
+    {
+        private readonly IProjectsRepository _projectsRepository;
+        private readonly IUnitOfWork _unitOfWork;
+
+        public CompletePlaningProjectCommandHandler(
+            IProjectsRepository projectsRepository,
+            IUnitOfWork unitOfWork
+            )
+        {
+
+            _projectsRepository = projectsRepository;
+            _unitOfWork = unitOfWork;
+
+        }
+
+        public async Task<Result> Handle(CompletePlaningProjectCommand request, CancellationToken cancellationToken)
+        {
+            Project project = await _projectsRepository.GetByIdAsync(request.ProjectId);
+            if (project is null)
+            {
+                return Result.Invalid(ProjectsErrors.InvalidEntryError);
+            }
+            else
+            {
+
+                project.Plan();
+
+                await _unitOfWork.SaveChangesAsync();
+
+                return Result.Success();
+
+
+
+            }
+        }
+    }
+
+}

PSManagement.Application/Projects/UseCases/Commands/CompleteProgressProject/CompleteProgressProjectCommand.cs

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

PSManagement.Application/Projects/UseCases/Commands/CompleteProgressProject/CompleteProgressProjectCommandHandler.cs

+using Ardalis.Result;
+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.CompleteProgressProject
+{
+    public class CompleteProgressProjectCommandHandler : ICommandHandler<CompleteProgressProjectCommand, Result>
+    {
+        private readonly IProjectsRepository _projectsRepository;
+        private readonly IUnitOfWork _unitOfWork;
+
+        public CompleteProgressProjectCommandHandler(
+            IProjectsRepository projectsRepository,
+            IUnitOfWork unitOfWork
+            )
+        {
+
+            _projectsRepository = projectsRepository;
+            _unitOfWork = unitOfWork;
+
+        }
+
+        public async Task<Result> Handle(CompleteProgressProjectCommand request, CancellationToken cancellationToken)
+        {
+            Project project = await _projectsRepository.GetByIdAsync(request.ProjectId);
+            if (project is null)
+            {
+                return Result.Invalid(ProjectsErrors.InvalidEntryError);
+            }
+            else
+            {
+
+                project.Complete();
+
+                await _unitOfWork.SaveChangesAsync();
+
+                return Result.Success();
+
+
+
+            }
+        }
+    }
+
+}

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

@@ -40,18 +40,21 @@ namespace PSManagement.Application.Projects.UseCases.Commands.CreateProject
                 .WithTeamLeader(request.TeamLeaderId)
                 .WithProposer(request.ProposerId)
                 .Build();
-            Project AddedProject =await _projectsRepository.AddAsync(project);
+            
+            project.Propose();
+
+            project =await _projectsRepository.AddAsync(project);
             CreateProjectResult response = new (
-                AddedProject.Id,
-                AddedProject.ProposalInfo,
-                AddedProject.ProjectInfo,
-                AddedProject.ProjectAggreement,
-                AddedProject.TeamLeaderId,
-                AddedProject.ProjectManagerId,
-                AddedProject.ExecuterId
+                project.Id,
+                project.ProposalInfo,
+                project.ProjectInfo,
+                project.ProjectAggreement,
+                project.TeamLeaderId,
+                project.ProjectManagerId,
+                project.ExecuterId
                 );
-            project.Propose();
-            project.AddDomainEvent(new ProjectCreatedEvent(AddedProject.Id,AddedProject.TeamLeaderId,AddedProject.ProjectManagerId));
+
+            project.AddDomainEvent(new ProjectCreatedEvent(project.Id,project.TeamLeaderId,project.ProjectManagerId));
             await _unitOfWork.SaveChangesAsync();
             return Result.Success(response);
 

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

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

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

+using Ardalis.Result;
+using PSManagement.Domain.Projects.DomainErrors;
+using PSManagement.Domain.Projects.DomainEvents;
+using PSManagement.Domain.Projects.Entities;
+using PSManagement.Domain.Projects.Repositories;
+using PSManagement.SharedKernel.CQRS.Command;
+using PSManagement.SharedKernel.Interfaces;
+using PSManagement.SharedKernel.Repositories;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace PSManagement.Application.Projects.UseCases.Commands.RemoveParticipant
+{
+    public class AddParticipantCommandHandler : ICommandHandler<RemoveParticipantCommand, Result>
+    {
+        private readonly IProjectsRepository _projectsRepository;
+        private readonly IRepository<EmployeeParticipate> _employeeParticipateRepository;
+        private readonly IUnitOfWork _unitOfWork;
+
+        public AddParticipantCommandHandler(
+            IRepository<EmployeeParticipate> repository,
+            IProjectsRepository projectsRepository,
+            IUnitOfWork unitOfWork)
+        {
+            _employeeParticipateRepository = repository;
+
+            _projectsRepository = projectsRepository;
+            _unitOfWork = unitOfWork;
+        }
+
+        public async Task<Result> Handle(RemoveParticipantCommand request, CancellationToken cancellationToken)
+        {
+            Project project = await _projectsRepository.GetByIdAsync(request.ProjectId);
+            if (project is null)
+            {
+                return Result.Invalid(ProjectsErrors.InvalidEntryError);
+            }
+            else
+            {
+
+                if (project.EmployeeParticipates.Where(e => e.Id == request.ParticipantId) is null)
+                {
+
+                    return Result.Invalid(ProjectsErrors.ParticipantUnExistError);
+                }
+                else
+                {
+                    EmployeeParticipate participant = await _employeeParticipateRepository.GetByIdAsync(request.ParticipantId);
+
+                    await _employeeParticipateRepository.DeleteAsync(participant);
+                    project.AddDomainEvent(new ParticipantRemovedEvent(request.ParticipantId, request.ProjectId));
+
+                    await _unitOfWork.SaveChangesAsync();
+
+                    return Result.Success();
+                }
+
+
+            }
+        }
+    }
+
+}

PSManagement.Application/Projects/UseCases/Queries/GetParticipants/GetProjectParticipants.cs

+using Ardalis.Result;
+using PSManagement.Application.Projects.Common;
+using PSManagement.SharedKernel.CQRS.Query;
+using System.Collections.Generic;
+
+namespace PSManagement.Application.Projects.UseCases.Queries.GetParticipants
+{
+    public record GetProjectParticipantsQuery(
+        int ProjectId
+        ) : IQuery<Result<IEnumerable<EmployeeParticipateDTO>>>;
+
+}

PSManagement.Application/Projects/UseCases/Queries/GetParticipants/GetProjectParticipantsQueryHandler.cs

+using Ardalis.Result;
+using AutoMapper;
+using PSManagement.Application.Projects.Common;
+using PSManagement.Domain.Projects.Repositories;
+using PSManagement.SharedKernel.CQRS.Query;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace PSManagement.Application.Projects.UseCases.Queries.GetParticipants
+{
+    public class GetProjectParticipantsQueryHandler : IQueryHandler<GetProjectParticipantsQuery, Result<IEnumerable<EmployeeParticipateDTO>>>
+    {
+        private readonly IProjectsRepository _projectRepository;
+        private readonly IMapper _mapper;
+
+        public GetProjectParticipantsQueryHandler(
+            IProjectsRepository projectRepository,
+            IMapper mapper)
+        {
+            _projectRepository = projectRepository;
+            _mapper = mapper;
+        }
+
+        public async Task<Result<IEnumerable<EmployeeParticipateDTO>>> Handle(GetProjectParticipantsQuery request, CancellationToken cancellationToken)
+        {
+            var project = await _projectRepository.GetByIdAsync(request.ProjectId);
+            if (project == null)
+            {
+                return Result.NotFound("Project not found");
+            }
+            IEnumerable<EmployeeParticipateDTO> result = _mapper.Map<IEnumerable<EmployeeParticipateDTO>>(_projectRepository.GetProjectParticipants(request.ProjectId));
+            if (result is null)
+            {
+                result = new List<EmployeeParticipateDTO>();
+            }
+            return Result.Success(result);
+        }
+    }
+
+}

PSManagement.Application/Projects/UseCases/Queries/GetProject/GetProjectByIdQuery.cs

+using Ardalis.Result;
+using PSManagement.Application.Projects.Common;
+using PSManagement.SharedKernel.CQRS.Query;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace PSManagement.Application.Projects.UseCases.Queries.GetProject
+{
+    public record GetProjectByIdQuery(
+         int ProjectId
+          ) : IQuery<Result<ProjectDTO>>;
+}

PSManagement.Application/Projects/UseCases/Queries/GetProject/GetProjectByIdQueryHandler.cs

+using Ardalis.Result;
+using AutoMapper;
+using PSManagement.Application.Projects.Common;
+using PSManagement.Domain.Projects;
+using PSManagement.Domain.Projects.Entities;
+using PSManagement.Domain.Projects.Repositories;
+using PSManagement.SharedKernel.CQRS.Query;
+using PSManagement.SharedKernel.Specification;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace PSManagement.Application.Projects.UseCases.Queries.GetProject
+{
+    public class GetProjectByIdQueryHandler : IQueryHandler<GetProjectByIdQuery, Result<ProjectDTO>>
+    {
+        private readonly IProjectsRepository _projectRepository;
+        private readonly BaseSpecification<Project> _specification;
+        private readonly IMapper _mapper;
+
+        public GetProjectByIdQueryHandler(
+            IProjectsRepository projectRepository,
+            IMapper mapper)
+        {
+            _projectRepository = projectRepository;
+            _mapper = mapper;
+            _specification = new ProjectSpecification();
+        }
+
+        public async Task<Result<ProjectDTO>> Handle(GetProjectByIdQuery request, CancellationToken cancellationToken)
+        {
+            _specification.Includes.Add(p=> p.EmployeeParticipates);
+            _specification.Includes.Add(p => p.FinancialSpending);
+            _specification.Includes.Add(p => p.ProjectManager);
+            _specification.Includes.Add(p => p.Attachments);
+            _specification.Includes.Add(p => p.TeamLeader);
+            _specification.Includes.Add(p => p.Executer);
+
+
+
+            var project = await _projectRepository.GetByIdAsync(request.ProjectId,_specification);
+            if (project == null)
+            {
+                return Result.NotFound("Project not found");
+            }
+
+            return _mapper.Map<ProjectDTO>(project);
+        }
+    }
+}

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

+using Ardalis.Result;
+using PSManagement.Application.Projects.Common;
+using PSManagement.SharedKernel.CQRS.Query;
+using System.Collections.Generic;
+
+namespace PSManagement.Application.Projects.UseCases.Queries.ListAllProject
+{
+    public record ListAllProjectsQuery(
+        int? PageNumber,
+        int? PageSize
+        ) : IQuery<Result<IEnumerable<ProjectDTO>>>;
+
+}

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

+using Ardalis.Result;
+using AutoMapper;
+using PSManagement.Application.Projects.Common;
+using PSManagement.Domain.Projects;
+using PSManagement.Domain.Projects.Entities;
+using PSManagement.Domain.Projects.Repositories;
+using PSManagement.SharedKernel.CQRS.Query;
+using PSManagement.SharedKernel.Specification;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace PSManagement.Application.Projects.UseCases.Queries.ListAllProject
+{
+    public class ListAllProjectsQueryHandler : IQueryHandler<ListAllProjectsQuery, Result<IEnumerable<ProjectDTO>>>
+    {
+        private readonly IProjectsRepository _projectsRepository;
+        private readonly BaseSpecification<Project> _specification;
+        private readonly IMapper _mapper;
+
+        public ListAllProjectsQueryHandler(
+            IProjectsRepository projectsRepository, 
+            IMapper mapper)
+        {
+            _projectsRepository = projectsRepository;
+            _specification = new ProjectSpecification();
+            _mapper = mapper;
+        }
+
+        public async Task<Result<IEnumerable<ProjectDTO>>> 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);
+            _specification.AddInclude(e => e.Executer);
+
+
+
+            _specification.ApplyPaging((pageNumber - 1) * pageSize, pageSize);
+
+            var projects = await _projectsRepository.ListAsync(_specification);
+
+            return Result.Success(_mapper.Map<IEnumerable<ProjectDTO>>(projects));    
+        }
+    }
+
+}

PSManagement.Application/Steps/Common/StepDTO.cs

+using PSManagement.Domain.Projects.ValueObjects;
+
+namespace PSManagement.Application.Projects.Common
+{
+    public class StepDTO
+    {
+        public int Id { get; set; }
+        public StepInfo StepInfo { get; set; }
+        public int CurrentCompletionRatio { get; set; }
+        public int Weight { get; set; }
+        public int ProjectId { get; set; }
+    }
+}
\ No newline at end of file

PSManagement.Application/Tracks/Common/EmployeeTrackDTO.cs

+namespace PSManagement.Application.Tracks.Common
+{
+    public class EmployeeTrackDTO
+    {
+    }
+}
\ No newline at end of file

PSManagement.Application/Tracks/Common/StepTrackDTO.cs

+namespace PSManagement.Application.Tracks.Common
+{
+    public class StepTrackDTO
+    {
+    }
+}
\ No newline at end of file

PSManagement.Application/Tracks/Common/TrackDTO.cs

+using PSManagement.Application.Employees.Common;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PSManagement.Application.Tracks.Common
+{
+    public class TrackDTO
+    {
+        public int Id { get; set; }
+        public DateTime TrackDate { get; set; }
+        public String TrackNote { get; set; }
+        public int ProjectId { get; set; }
+
+    }
+}