implement CQRS for emploees domain

PSManagement.Api/Controllers/Employees/EmployeesController.cs

-using Microsoft.AspNetCore.Http;
+using Ardalis.Result;
+using AutoMapper;
+using MediatR;
+using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using PSManagement.Api.Controllers.ApiBase;
 using PSManagement.Application.Contracts.Providers;
 using PSManagement.Application.Contracts.SyncData;
+using PSManagement.Application.Employees.UseCases.Commands.UpdateEmployeeWorkHours;
+using PSManagement.Application.Employees.UseCases.Queries.GetAvailableEmployees;
+using PSManagement.Application.Employees.UseCases.Queries.GetEmployeeById;
+using PSManagement.Application.Employees.UseCases.Queries.GetEmployeesByFilter;
+using PSManagement.Contracts.Employees.Requests;
+using PSManagement.Contracts.Projects.Response;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -15,12 +24,61 @@ namespace PSManagement.Api.Controllers.Employees
     {
         private readonly ISyncEmployeesService _syncEmployeesService;
         private readonly IEmployeesProvider _employeesProvider;
-        public EmployeesController(ISyncEmployeesService syncEmployeesService)
+        private readonly IMediator _sender;
+        private readonly IMapper _mapper;
+
+        public EmployeesController(
+            ISyncEmployeesService syncEmployeesService,
+            IMapper mapper,
+            IMediator sender)
         {
             _syncEmployeesService = syncEmployeesService;
+            _mapper = mapper;
+            _sender = sender;
+        }
+
+
+        [HttpGet("{id}")]
+        public async Task<IActionResult> Get(int id)
+        {
+            var query = new GetEmployeeByIdQuery(id);
+
+            var result = await _sender.Send(query);
+
+            return Ok(_mapper.Map<Result<EmployeeResponse>>(result));
+        }
+
+        [HttpGet("ByFilter")]
+        public async Task<IActionResult> GetByFilter([FromQuery]GetEmployeesByFilterRequest request)
+        {
+            GetEmployeesByFilterQuery query = _mapper.Map<GetEmployeesByFilterQuery>(request);
+
+            var result = await _sender.Send(query);
+
+            return Ok(_mapper.Map<Result<IEnumerable<EmployeeResponse>>>(result));
+        }
+
+        [HttpGet]
+        public async Task<IActionResult> GetAll([FromQuery]GetAvailableEmployeesRequest request)
+        {
+            GetAvailableEmployeesQuery query = _mapper.Map<GetAvailableEmployeesQuery>(request);
+
+            var result = await _sender.Send(query);
+
+            return Ok(_mapper.Map<Result<IEnumerable<EmployeeResponse>>>(result));
         }
 
 
+        [HttpPost("EmployeeParticipations")]
+        public async Task<IActionResult> GetEmployeeParticipations([FromForm] GetEmployeeParticipationRequest request)
+        {
+            var command = _mapper.Map<GetEmployeeParticipationQuery>(request);
+            var result = await _sender.Send(command);
+
+            return Ok(_mapper.Map<Result<IEnumerable<EmployeeParticipateResponse>>>(result));
+
+        }
+
         [HttpPost("SyncEmployees")]
         public async Task<IActionResult> Post()
         {
@@ -29,5 +87,16 @@ namespace PSManagement.Api.Controllers.Employees
             return Ok(response);
 
         }
+
+        [HttpPost("UpdateWorkHours")]
+        public async Task<IActionResult> UpdateWorkHours(UpdateEmployeeWorkHoursRequest request)
+        {
+            UpdateEmployeeWorkHoursCommand query =_mapper.Map<UpdateEmployeeWorkHoursCommand>(request);
+
+            var result = await _sender.Send(query);
+
+            return Ok(result);
+
+        }
     }
 }

PSManagement.Api/Controllers/Projects/ProjectsController.cs

@@ -45,6 +45,16 @@ namespace PSManagement.Api.Controllers.Projects
         }
 
 
+        [HttpGet("ByFilter")]
+        public async Task<IActionResult> GetByFilter([FromQuery] GetProjectsByFilterRequest request)
+        {
+            GetProjectsByFilterQuery query = _mapper.Map<GetProjectsByFilterQuery>(request);
+
+            var result = await _sender.Send(query);
+
+            return Ok(_mapper.Map<Result<IEnumerable<ProjectResponse>>>(result));
+        }
+
         [HttpGet("GetParticipants{id}")]
         public async Task<IActionResult> GetParticipants(int id)
         {

PSManagement.Application/ApplicationDTOsMappers/MapperConfiguration.cs

@@ -27,13 +27,21 @@ namespace PSManagement.Application.Mappers
 
             CreateMap<StepDTO, Step>().ReverseMap();
 
-            CreateMap<EmployeeDTO, Employee>().ReverseMap();
-            CreateMap<EmployeeParticipateDTO, EmployeeParticipate>().ReverseMap();
+            CreateMap<Employee, EmployeeDTO>()
+                .ForMember(e => e.DepartmentName, op => op.MapFrom(e => e.Department.Name));
+            CreateMap<EmployeeParticipateDTO, EmployeeParticipate>()
+                .ForMember(d=>d.Project ,op =>op.Ignore())
+                ;
+            CreateMap< EmployeeParticipate, EmployeeParticipateDTO>()
+                .ForMember(d => d.ProjectInfo, op => op.MapFrom(e => e.Project.ProjectInfo));
+                
+            CreateMap<EmployeeParticipate, EmployeeParticipateDTO>()
+                .ForMember(d => d.ProjectInfo, op => op.MapFrom(e=>e.Project.ProjectInfo));
+
 
             CreateMap<TrackDTO, Track>().ReverseMap();
             CreateMap<FinancialSpendingDTO, FinancialSpending>().ReverseMap();
-            CreateMap<Project, ProjectDTO>()
-                      .ReverseMap(); // This allows for mapping in the reverse direction as well
+            CreateMap<Project, ProjectDTO>().ReverseMap();
 
         }
     }

PSManagement.Application/Employees/Common/EmployeeDTO.cs

@@ -12,6 +12,7 @@ namespace PSManagement.Application.Employees.Common
         public int Id { get; set; }
         public int HIASTId { get; set; }
         public int UserId { get; set; }
+        public String DepartmentName { get; set; }
         public PersonalInfo PersonalInfo { get; set; }
         public WorkInfo WorkInfo { get; set; }
 

PSManagement.Application/Employees/UseCases/Commands/SyncEmployees/SyncEmployeesCommandHandler.cs

+using Ardalis.Result;
+using PSManagement.Application.Contracts.Providers;
+using PSManagement.Application.Contracts.SyncData;
+using PSManagement.SharedKernel.CQRS.Command;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace PSManagement.Application.Employees.UseCases.Commands.SyncEmployeesData
+{
+    public class SyncEmployeesCommandHandler : ICommandHandler<SyncEmployeesCommand, Result<SyncResponse>>
+    {
+        private readonly ISyncEmployeesService _syncEmployeesService;
+        private readonly IEmployeesProvider _employeesProvider;
+
+        public SyncEmployeesCommandHandler(
+            ISyncEmployeesService syncEmployeesService,
+            IEmployeesProvider employeesProvider)
+        {
+            _syncEmployeesService = syncEmployeesService;
+            _employeesProvider = employeesProvider;
+        }
+
+        public async Task<Result<SyncResponse>> Handle(SyncEmployeesCommand request, CancellationToken cancellationToken)
+        {
+            SyncResponse response = await _syncEmployeesService.SyncEmployees(_employeesProvider);
+
+            return response;
+
+        }
+    }
+}

PSManagement.Application/Employees/UseCases/Commands/SyncEmployees/SyncEmployeesDatatCommand.cs

+using Ardalis.Result;
+using PSManagement.Application.Contracts.SyncData;
+using PSManagement.SharedKernel.CQRS.Command;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace PSManagement.Application.Employees.UseCases.Commands.SyncEmployeesData
+{
+    public record SyncEmployeesCommand():ICommand<Result<SyncResponse>>;
+
+}

PSManagement.Application/Employees/UseCases/Commands/UpdateEmployeeWorkHours/UpdateEmployeeWorkHoursCommand.cs

+using Ardalis.Result;
+using PSManagement.Application.Contracts.SyncData;
+using PSManagement.SharedKernel.CQRS.Command;
+using PSManagement.SharedKernel.Interfaces;
+
+namespace PSManagement.Application.Employees.UseCases.Commands.UpdateEmployeeWorkHours
+{
+    public record UpdateEmployeeWorkHoursCommand(
+        int EmployeeId,
+        int WorkingHour) : ICommand<Result>;
+
+}

PSManagement.Application/Employees/UseCases/Commands/UpdateEmployeeWorkHours/UpdateEmployeeWorkHoursCommandHandler.cs

+using Ardalis.Result;
+using PSManagement.Domain.Employees.DomainErrors;
+using PSManagement.Domain.Employees.Entities;
+using PSManagement.Domain.Employees.Repositories;
+using PSManagement.SharedKernel.CQRS.Command;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace PSManagement.Application.Employees.UseCases.Commands.UpdateEmployeeWorkHours
+{
+    public class UpdateEmployeeWorkHoursCommandHandler : ICommandHandler<UpdateEmployeeWorkHoursCommand, Result>
+    {
+        private readonly IEmployeesRepository _employeesRepository;
+        private readonly static int _workHourLimit = 70;
+
+        public UpdateEmployeeWorkHoursCommandHandler(IEmployeesRepository employeesRepository)
+        {
+            _employeesRepository = employeesRepository;
+        }
+
+        public async Task<Result> Handle(UpdateEmployeeWorkHoursCommand request, CancellationToken cancellationToken)
+        {
+            Employee employee =await _employeesRepository.GetByIdAsync(request.EmployeeId);
+            if (request.WorkingHour < _workHourLimit)
+            {
+                employee.Availability = new(request.WorkingHour, employee.Availability.IsAvailable);
+
+                await _employeesRepository.UpdateAsync(employee);
+
+                return Result.Success();
+            }
+            else {
+
+                return Result.Invalid(EmployeesErrors.WorkHourLimitExceeded);
+            
+            }
+
+        }
+    }
+
+}

PSManagement.Application/Employees/UseCases/Queries/GetAvailableEmployees/GetAvailableEmployeesQuery.cs

+using Ardalis.Result;
+using PSManagement.Application.Employees.Common;
+using PSManagement.SharedKernel.CQRS.Command;
+using PSManagement.SharedKernel.CQRS.Query;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace PSManagement.Application.Employees.UseCases.Queries.GetAvailableEmployees
+{
+    public record GetAvailableEmployeesQuery (
+        int? PageNumber,
+        int? PageSize) : IQuery<Result<IEnumerable<EmployeeDTO>>>;
+}

PSManagement.Application/Employees/UseCases/Queries/GetAvailableEmployees/GetAvailableEmployeesQueryHandler.cs

+using Ardalis.Result;
+using AutoMapper;
+using PSManagement.Application.Employees.Common;
+using PSManagement.Domain.Employees.Entities;
+using PSManagement.Domain.Employees.Repositories;
+using PSManagement.Domain.Employees.Specification;
+using PSManagement.SharedKernel.CQRS.Query;
+using PSManagement.SharedKernel.Specification;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace PSManagement.Application.Employees.UseCases.Queries.GetAvailableEmployees
+{
+    public class GetAvailableEmployeesQueryHandler : IQueryHandler<GetAvailableEmployeesQuery, Result<IEnumerable<EmployeeDTO>>>
+    {
+        private readonly IEmployeesRepository _employeesRepository;
+        private readonly IMapper _mapper;
+        private readonly BaseSpecification<Employee> _specification;
+
+        public GetAvailableEmployeesQueryHandler(
+            IEmployeesRepository employeesRepository,
+            IMapper mapper)
+        {
+            _employeesRepository = employeesRepository;
+            _mapper = mapper;
+            _specification = new EmployeesSpecification();
+        }
+
+        public async Task<Result<IEnumerable<EmployeeDTO>>> Handle(GetAvailableEmployeesQuery 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.ApplyPaging((pageNumber - 1) * pageSize, pageSize);
+            _specification.AddInclude(e => e.Department);
+
+            return Result.Success(_mapper.Map<IEnumerable<EmployeeDTO>>(await _employeesRepository.ListAsync(_specification)));
+        }
+    }
+}

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

+using Ardalis.Result;
+using PSManagement.Application.Employees.Common;
+using PSManagement.SharedKernel.CQRS.Query;
+
+namespace PSManagement.Application.Employees.UseCases.Queries.GetEmployeeById
+{
+    public record GetEmployeeByIdQuery(
+        int EmployeeId) : IQuery<Result<EmployeeDTO>>;
+
+}

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

+using Ardalis.Result;
+using AutoMapper;
+using PSManagement.Application.Employees.Common;
+using PSManagement.Domain.Employees.Entities;
+using PSManagement.Domain.Employees.Repositories;
+using PSManagement.Domain.Employees.Specification;
+using PSManagement.SharedKernel.CQRS.Query;
+using PSManagement.SharedKernel.Specification;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace PSManagement.Application.Employees.UseCases.Queries.GetEmployeeById
+{
+    public class GetEmployeeByIdQueryHandler : IQueryHandler<GetEmployeeByIdQuery, Result<EmployeeDTO>>
+    {
+        private readonly IEmployeesRepository _employeesRepository;
+        private readonly IMapper _mapper;
+        private readonly BaseSpecification<Employee> _specification;
+
+        public GetEmployeeByIdQueryHandler(
+            IEmployeesRepository employeesRepository,
+            IMapper mapper)
+        {
+            _employeesRepository = employeesRepository;
+            _mapper = mapper;
+            _specification = new EmployeesSpecification();
+        }
+
+        public async Task<Result<EmployeeDTO>> Handle(GetEmployeeByIdQuery request, CancellationToken cancellationToken)
+        {
+           
+            return Result.Success(_mapper.Map<EmployeeDTO>(await _employeesRepository.GetByIdAsync(request.EmployeeId,_specification)));
+        }
+    }
+
+}

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

+using Ardalis.Result;
+using PSManagement.Application.Projects.Common;
+using PSManagement.Domain.Employees.Entities;
+using PSManagement.Domain.Employees.Repositories;
+using PSManagement.Domain.Employees.Specification;
+using PSManagement.SharedKernel.CQRS.Query;
+using System.Collections.Generic;
+
+namespace PSManagement.Application.Employees.UseCases.Queries.GetEmployeeById
+{
+    public record GetEmployeeParticipationQuery(
+        int EmployeeId,
+        int? PageNumber,
+        int? PageSize) : IQuery<Result<IEnumerable<EmployeeParticipateDTO>>>;
+}

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

+using Ardalis.Result;
+using AutoMapper;
+using PSManagement.Application.Projects.Common;
+using PSManagement.Domain.Projects;
+using PSManagement.Domain.Projects.Entities;
+using PSManagement.SharedKernel.CQRS.Query;
+using PSManagement.SharedKernel.Repositories;
+using PSManagement.SharedKernel.Specification;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Linq;
+
+namespace PSManagement.Application.Employees.UseCases.Queries.GetEmployeeById
+{
+    public class GetEmployeeParticipationQueryHandler : IQueryHandler<GetEmployeeParticipationQuery, Result<IEnumerable<EmployeeParticipateDTO>>>
+    {
+        private readonly IRepository<EmployeeParticipate> _employeesParticipateRepository;
+        private readonly IMapper _mapper;
+        private readonly BaseSpecification<EmployeeParticipate> _specification;
+
+        public GetEmployeeParticipationQueryHandler(
+           IRepository<EmployeeParticipate> employeesParticipateRepository,
+            IMapper mapper)
+        {
+            _employeesParticipateRepository = employeesParticipateRepository;
+            _mapper = mapper;
+            _specification = new EmployeeParticipateSpecification();
+        }
+
+        public async Task<Result<IEnumerable<EmployeeParticipateDTO>>> Handle(GetEmployeeParticipationQuery 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.ApplyPaging((pageNumber - 1) * pageSize, pageSize);
+
+            _specification.AddInclude(e => e.Project);
+
+            IEnumerable<EmployeeParticipate> response = await _employeesParticipateRepository.ListAsync(_specification);
+
+            response =response.Where(e => e.EmployeeId == request.EmployeeId);
+
+            return Result.Success(_mapper.Map<IEnumerable<EmployeeParticipateDTO>>(response));
+        }
+    }
+
+
+}

PSManagement.Application/Employees/UseCases/Queries/GetEmployeesByFilter/GetEmployeesByFilterQuery.cs

+using Ardalis.Result;
+using PSManagement.Application.Employees.Common;
+using PSManagement.SharedKernel.CQRS.Query;
+using PSManagement.SharedKernel.Repositories;
+using System.Collections.Generic;
+namespace PSManagement.Application.Employees.UseCases.Queries.GetEmployeesByFilter
+{
+    public record GetEmployeesByFilterQuery(
+         string EmployeeFirstName,
+         int? HiastId,
+         string DepartmentName,
+         string WorkType
+    ) : IQuery<Result<IEnumerable<EmployeeDTO>>>;
+
+}

PSManagement.Application/Employees/UseCases/Queries/GetEmployeesByFilter/GetEmployeesByFilterQueryHandler.cs

+using Ardalis.Result;
+using AutoMapper;
+using PSManagement.Application.Employees.Common;
+using PSManagement.Domain.Employees.Entities;
+using PSManagement.Domain.Employees.Repositories;
+using PSManagement.Domain.Employees.Specification;
+using PSManagement.SharedKernel.CQRS.Query;
+using PSManagement.SharedKernel.Specification;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Linq;
+namespace PSManagement.Application.Employees.UseCases.Queries.GetEmployeesByFilter
+{
+    public class GetEmployeesByFilterQueryHandler : IQueryHandler<GetEmployeesByFilterQuery, Result<IEnumerable<EmployeeDTO>>>
+    {
+        private readonly IEmployeesRepository _employeesRepository;
+        private readonly IMapper _mapper;
+        private readonly BaseSpecification<Employee> _specification;
+
+        public GetEmployeesByFilterQueryHandler(
+           IEmployeesRepository employeesRepository,
+            IMapper mapper)
+        {
+            _employeesRepository = employeesRepository;
+            _mapper = mapper;
+            _specification = new EmployeesSpecification();
+        }
+
+        public async Task<Result<IEnumerable<EmployeeDTO>>> Handle(GetEmployeesByFilterQuery request, CancellationToken cancellationToken)
+        {
+            _specification.AddInclude(e=>e.Department);
+
+            IEnumerable<Employee> employees =await _employeesRepository.ListAsync(_specification);
+            if (!string.IsNullOrEmpty(request.DepartmentName))
+            {
+                employees = employees.Where(e => e.Department.Name.ToLower().Contains(request.DepartmentName.Trim().ToLower()));
+            }
+            if (!string.IsNullOrEmpty(request.EmployeeFirstName))
+            {
+                employees = employees.Where(e => e.PersonalInfo.FirstName.ToLower().Contains( request.EmployeeFirstName.Trim().ToLower()));
+            }
+
+            if (request.HiastId.HasValue)
+            {
+                employees = employees.Where(e => e.HIASTId== request.HiastId);
+            }
+
+            if (!string.IsNullOrEmpty(request.WorkType))
+            {
+                employees = employees.Where(e => e.WorkInfo.WorkType.ToLower().Contains(request.WorkType.ToLower().Trim()));
+            }
+
+            return Result.Success(_mapper.Map<IEnumerable<EmployeeDTO>>(employees));
+        }
+    }
+
+}

PSManagement.Application/PSManagement.Application.csproj

@@ -8,19 +8,13 @@
   <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="FinancialSpends\UseCases\Commands\CreateFinancialSpendingItem\" />
-    <Folder Include="FinancialSpends\UseCases\Commands\" />
+    <Folder Include="FinancialSpends\UseCases\Commands\RemoveFinancialSpendingItem\" />
     <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\GetProjectFinicialSpending\" />
+    <Folder Include="Steps\UseCases\Queries\GetStepsByProject\" />
     <Folder Include="XReports\UseCases\" />
     <Folder Include="XReports\UseCases\Queries\" />
     <Folder Include="Steps\UseCases\Commands\ChangeStepWeight\" />

PSManagement.Application/Projects/Common/EmployeeParticipateDTO.cs

 using PSManagement.Application.Employees.Common;
+using PSManagement.Domain.Projects.ValueObjects;
 
 namespace PSManagement.Application.Projects.Common
 {
@@ -6,6 +7,7 @@ namespace PSManagement.Application.Projects.Common
     {
         public int EmployeeId { get; set; }
         public int ProjectId { get; set; }
+        public ProjectInfo ProjectInfo { get; set; }
         public EmployeeDTO Employee { get; set; }
         public int PartialTimeRatio { get; set; }
         public string Role { get; set; }

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

@@ -12,25 +12,31 @@ using System.Linq;
 using PSManagement.Domain.Projects.DomainEvents;
 using PSManagement.SharedKernel.Specification;
 using PSManagement.Domain.Projects;
+using PSManagement.Domain.Employees.Entities;
+using PSManagement.Domain.Employees.Repositories;
+using PSManagement.Domain.Employees.DomainErrors;
 
 namespace PSManagement.Application.Projects.UseCases.Commands.AddParticipant
 {
     public class AddParticipantCommandHandler : ICommandHandler<AddParticipantCommand, Result>
     {
         private readonly IProjectsRepository _projectsRepository;
+        private readonly IEmployeesRepository _employeesRepository;
         private readonly IRepository<EmployeeParticipate> _employeeParticipateRepository;
         private readonly IUnitOfWork _unitOfWork;
         private readonly BaseSpecification<Project> _specification;
 
         public AddParticipantCommandHandler(
             IRepository<EmployeeParticipate> repository,
-            IProjectsRepository projectsRepository, 
-            IUnitOfWork unitOfWork)
+            IProjectsRepository projectsRepository,
+            IUnitOfWork unitOfWork,
+            IEmployeesRepository employeesRepository)
         {
             _employeeParticipateRepository = repository;
             _specification = new ProjectSpecification();
             _projectsRepository = projectsRepository;
             _unitOfWork = unitOfWork;
+            _employeesRepository = employeesRepository;
         }
 
         public async Task<Result> Handle(AddParticipantCommand request, CancellationToken cancellationToken)
@@ -48,8 +54,14 @@ namespace PSManagement.Application.Projects.UseCases.Commands.AddParticipant
                     return Result.Invalid(ProjectsErrors.ParticipantExistError);
                 }
                 else {
+                    Employee employee = await _employeesRepository.GetByIdAsync(request.ParticipantId);
+                    if (employee is null) {
 
+                        return Result.Invalid(EmployeesErrors.EmployeeUnExist);
+
+                    }
                     await _employeeParticipateRepository.AddAsync(new (request.ParticipantId,request.ProjectId,request.Role,request.PartialTimeRatio));
+                    
                     project.AddDomainEvent(new ParticipantAddedEvent(request.ParticipantId,request.ProjectId,request.PartialTimeRatio,request.Role));
 
                     await _unitOfWork.SaveChangesAsync();

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

@@ -39,7 +39,7 @@ namespace PSManagement.Application.Projects.UseCases.Commands.RemoveParticipant
             else
             {
 
-                if (project.EmployeeParticipates.Where(e => e.Id == request.ParticipantId) is null)
+                if (project.EmployeeParticipates?.Where(e => e.Id == request.ParticipantId) is null)
                 {
 
                     return Result.Invalid(ProjectsErrors.ParticipantUnExistError);

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

@@ -4,6 +4,7 @@ using PSManagement.Application.Projects.Common;
 using PSManagement.Domain.Projects.Repositories;
 using PSManagement.SharedKernel.CQRS.Query;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -29,11 +30,13 @@ namespace PSManagement.Application.Projects.UseCases.Queries.GetParticipants
             {
                 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>();
             }
+            result = result.Select(e => { e.ProjectInfo = project.ProjectInfo; return e; });
             return Result.Success(result);
         }
     }

PSManagement.Application/Projects/UseCases/Queries/GetProjectsByFilter/GetProjectsByFilterQuery.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 GetProjectsByFilterQuery(
+         string ProjectName,
+         string TeamLeaderName,
+         string DepartmentName,
+         string ProposerName
+     ) : IQuery<Result<IEnumerable<ProjectDTO>>>;
+
+}

PSManagement.Application/Projects/UseCases/Queries/GetProjectsByFilter/GetProjectsByFilterQueryHandler.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.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace PSManagement.Application.Projects.UseCases.Queries.ListAllProject
+{
+    public class GetProjectsByFilterQueryHandler : IQueryHandler<GetProjectsByFilterQuery, Result<IEnumerable<ProjectDTO>>>
+    {
+        private readonly IProjectsRepository _projectsRepository;
+        private readonly IMapper _mapper;
+
+        public GetProjectsByFilterQueryHandler(
+            IMapper mapper,
+            IProjectsRepository projectsRepository)
+        {
+            _mapper = mapper;
+            _projectsRepository = projectsRepository;
+            _specification = new ProjectSpecification();
+        }
+
+        private readonly BaseSpecification<Project> _specification;
+
+        public async Task<Result<IEnumerable<ProjectDTO>>> Handle(GetProjectsByFilterQuery request, CancellationToken cancellationToken)
+        {
+            _specification.AddInclude(e => e.TeamLeader);
+            _specification.AddInclude(e => e.Executer);
+            _specification.AddInclude(e => e.Proposer);
+
+
+            IEnumerable<Project> projects = await _projectsRepository.ListAsync(_specification);
+            if (!string.IsNullOrEmpty(request.DepartmentName))
+            {
+                projects = projects.Where(e => e.Executer.Name.ToLower().Contains(request.DepartmentName.Trim().ToLower()));
+            }
+
+            if (!string.IsNullOrEmpty(request.ProposerName))
+            {
+                projects = projects.Where(e => e.Proposer.CustomerName.ToLower().Contains(request.ProposerName.Trim().ToLower()));
+            }
+
+            if (!string.IsNullOrEmpty(request.TeamLeaderName))
+            {
+                projects = projects.Where(e => e.Proposer.CustomerName.ToLower().Contains(request.TeamLeaderName.Trim().ToLower()));
+            }
+
+            if (!string.IsNullOrEmpty(request.ProposerName))
+            {
+                projects = projects.Where(e => e.ProjectInfo.Name.ToLower().Contains(request.ProjectName.Trim().ToLower()));
+            }
+
+
+            return Result.Success(_mapper.Map<IEnumerable<ProjectDTO>>(projects));
+        }
+    }
+
+}

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

@@ -8,6 +8,7 @@ namespace PSManagement.Application.Projects.UseCases.Queries.ListAllProject
     public record ListAllProjectsQuery(
         int? PageNumber,
         int? PageSize
+
         ) : IQuery<Result<IEnumerable<ProjectDTO>>>;
 
 }

PSManagement.Contracts/Employees/Requests/GetAvailableEmployeesRequest.cs

+namespace PSManagement.Contracts.Employees.Requests
+{
+    public record GetAvailableEmployeesRequest(
+    int? PageNumber,
+    int? PageSize);
+
+}

PSManagement.Contracts/Employees/Requests/GetEmployeeParticipationRequest.cs

+namespace PSManagement.Contracts.Employees.Requests
+{
+    public record GetEmployeeParticipationRequest(
+        int EmployeeId,
+        int? PageNumber,
+        int? PageSize);
+}

PSManagement.Contracts/Employees/Requests/GetEmployeesByFilterRequest.cs

+namespace PSManagement.Contracts.Employees.Requests
+{
+    public record GetEmployeesByFilterRequest(
+     string EmployeeFirstName,
+     int? HiastId,
+     string DepartmentName,
+     string WorkType
+     ) ;
+}

PSManagement.Contracts/Employees/Requests/UpdateEmployeeWorkHoursRequest.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PSManagement.Contracts.Employees.Requests
+{
+    public record UpdateEmployeeWorkHoursRequest(
+       int EmployeeId,
+       int WorkingHour);
+}

PSManagement.Contracts/Projects/Response/EmployeeParticipateResponse.cs → PSManagement.Contracts/Employees/Response/EmployeeParticipateResponse.cs

@@ -6,7 +6,7 @@ namespace PSManagement.Contracts.Projects.Response
     {
         public int EmployeeId { get; set; }
         public int ProjectId { get; set; }
-        public EmployeResponse Employee { get; set; }
+        public EmployeeResponse Employee { get; set; }
         public int PartialTimeRatio { get; set; }
         public string Role { get; set; }
     }

PSManagement.Contracts/Employees/Response/EmployeeResponse.cs

@@ -7,6 +7,7 @@ namespace PSManagement.Contracts.Projects.Response
         public int Id { get; set; }
         public int HIASTId { get; set; }
         public int UserId { get; set; }
+        public string DepartmentName { get; set; }
         public PersonalInfo PersonalInfo { get; set; }
         public WorkInfo WorkInfo { get; set; }
     }

PSManagement.Contracts/PSManagement.Contracts.csproj

@@ -12,10 +12,10 @@
   <ItemGroup>
     <ProjectReference Include="..\PSManagement.Application\PSManagement.Application.csproj" />
     <ProjectReference Include="..\PSManagement.Domain\PSManagement.Domain.csproj" />
+    <ProjectReference Include="..\PSManagement.SharedKernel\PSManagement.SharedKernel.csproj" />
   </ItemGroup>
 
   <ItemGroup>
-    <Folder Include="Employees\Requests\" />
     <Folder Include="FinancialSpends\Requests\" />
     <Folder Include="Steps\Requests\" />
     <Folder Include="Tracks\Response\" />

PSManagement.Contracts/Projects/Requests/GetProjectsByFilterRequest.cs

+namespace PSManagement.Contracts.Projects.Requests
+{
+    public record GetProjectsByFilterRequest(
+     string ProjectName,
+     string TeamLeaderName,
+     string DepartmentName,
+     string ProposerName
+ );
+
+}

PSManagement.Domain/Employees/DomainErrors/EmployeesErrors.cs

@@ -10,6 +10,7 @@ namespace PSManagement.Domain.Employees.DomainErrors
     public class EmployeesErrors
     {
         public static readonly DomainError EmployeeUnExist = new("Employees.UnExist", "The Provided Credential Dosent match any employee.  ");
+        public static readonly DomainError WorkHourLimitExceeded = new("Employees.LimitHour", "The given work hours is more than the limited work hours.");
 
     }
 }

PSManagement.Domain/Employees/Entities/Employee.cs

@@ -17,6 +17,8 @@ namespace PSManagement.Domain.Employees.Entities
         public int HIASTId { get; set; }
         public int UserId { get; set; }
         public User User { get; set; }
+        public int DepartmentId { get; set; }
+        public Department Department { get; set; }
         public PersonalInfo PersonalInfo { get; set; }
         public WorkInfo WorkInfo { get; set; }
 

PSManagement.Domain/Projects/Specification/EmployeeParticipateSpecification.cs

+using PSManagement.Domain.Projects.Entities;
+using PSManagement.SharedKernel.Specification;
+using System;
+using System.Linq.Expressions;
+
+namespace PSManagement.Domain.Projects
+{
+    public class EmployeeParticipateSpecification : BaseSpecification<EmployeeParticipate>
+    {
+        public EmployeeParticipateSpecification(Expression<Func<EmployeeParticipate, bool>> criteria = null) : base(criteria)
+        {
+            AddInclude(u => u.Employee);
+
+        }
+    }
+}

PSManagement.Domain/Tracking/Entities/Track.cs

@@ -14,6 +14,7 @@ namespace PSManagement.Domain.Tracking
     public class Track : BaseEntity
     {
         public DateTime TrackDate { get; set; }
+        public bool IsCompleted { get; set; }
         public String TrackNote { get; set; }
         public int ProjectId { get; set; }
         public Project Project { get; set; }