implement the basic logic of the domains.

PSManagement.Api/Controllers/Employees/EmployeesController.cs

@@ -88,8 +88,8 @@ namespace PSManagement.Api.Controllers.Employees
 
         }
 
-        [HttpPost("UpdateWorkHours")]
-        public async Task<IActionResult> UpdateWorkHours(UpdateEmployeeWorkHoursRequest request)
+        [HttpPut("UpdateWorkHours")]
+        public async Task<IActionResult> PutUpdateWorkHours(UpdateEmployeeWorkHoursRequest request)
         {
             UpdateEmployeeWorkHoursCommand query =_mapper.Map<UpdateEmployeeWorkHoursCommand>(request);
 

PSManagement.Api/Controllers/FinancialSpends/FinancialSpendsController.cs

@@ -35,11 +35,25 @@ namespace PSManagement.Api.Controllers.FinancialSpends
         [HttpPost]
         public async Task<IActionResult> Post(CreateFinancialSpendItemRequest request)
         {
-            var query = _mapper.Map<CreateFinancialSpendItemCommand>(request);
+            var command = _mapper.Map<CreateFinancialSpendItemCommand>(request);
 
-            var result = await _sender.Send(query);
+            var result = await _sender.Send(command);
+
+            if (result.IsSuccess)
+            {
 
-            return Ok(result);
+                var query = new GetFinancialSpendItemByIdQuery(result.Value);
+                var response = await _sender.Send(query);
+
+                return Ok(_mapper.Map<FinancialSpendingResponse>(response));
+
+            }
+            else
+            {
+
+                return Ok(result);
+
+            }
         }
 
         [HttpGet]
@@ -81,7 +95,7 @@ namespace PSManagement.Api.Controllers.FinancialSpends
         {
             if (id != request.Id)
             {
-                Result.Conflict();
+                Result.Conflict("no match for the id");
             }
 
             var query = _mapper.Map<UpdateFinancialSpendItemCommand>(request);

PSManagement.Api/Controllers/Projects/ProjectsController.cs

@@ -54,6 +54,16 @@ namespace PSManagement.Api.Controllers.Projects
 
             return Ok(_mapper.Map<Result<IEnumerable<ProjectResponse>>>(result));
         }
+    
+        [HttpGet("ByProjectManager")]
+        public async Task<IActionResult> GetByBrojectManager(GetProjectsByProjectManagerRequest 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)
@@ -65,8 +75,9 @@ namespace PSManagement.Api.Controllers.Projects
             return Ok( _mapper.Map<Result<IEnumerable<EmployeeParticipateResponse>>>(result));
         }
 
+
         [HttpPost("ApproveProject")]
-        public async Task<IActionResult> ApproveProjectRequest(ApproveProjectRequest request)
+        public async Task<IActionResult> PostApproveProjectRequest(ApproveProjectRequest request)
         {
             var query = _mapper.Map<ApproveProjectCommand>(request);
 
@@ -75,8 +86,8 @@ namespace PSManagement.Api.Controllers.Projects
             return Ok(result);
         }
 
-        [HttpPost("ChangeTeamLeader")]
-        public async Task<IActionResult> ChangeTeamLeader(ChangeProjectTeamLeaderRequest request)
+        [HttpPut("ChangeTeamLeader")]
+        public async Task<IActionResult> PuttChangeTeamLeader(ChangeProjectTeamLeaderRequest request)
         {
             var query = _mapper.Map<ChangeProjectTeamLeaderCommand>(request);
 
@@ -87,7 +98,7 @@ namespace PSManagement.Api.Controllers.Projects
 
 
         [HttpPost("AddProjectStep")]
-        public async Task<IActionResult> AddParticipant(AddProjectStepRequest request)
+        public async Task<IActionResult> PostAddParticipant(AddProjectStepRequest request)
         {
             var query = _mapper.Map<AddProjectStepCommand>(request);
 
@@ -98,7 +109,7 @@ namespace PSManagement.Api.Controllers.Projects
 
 
         [HttpPost("RemoveParticipant")]
-        public async Task<IActionResult> RemoveParticipant(RemoveParticipantRequest request)
+        public async Task<IActionResult> PostRemoveParticipant(RemoveParticipantRequest request)
         {
             var query = _mapper.Map<RemoveParticipantCommand>(request);
 
@@ -107,8 +118,9 @@ namespace PSManagement.Api.Controllers.Projects
             return Ok(result);
         }
 
+
         [HttpPost("AddParticipant")]
-        public async Task<IActionResult> AddParticipant(AddParticipantRequest request)
+        public async Task<IActionResult> PostAddParticipant(AddParticipantRequest request)
         {
             var query = _mapper.Map<AddParticipantCommand>(request);
 
@@ -129,17 +141,32 @@ namespace PSManagement.Api.Controllers.Projects
             return Ok(_mapper.Map<Result<ProjectResponse>>(result));
         }
 
+
         [HttpPost]
         public async Task<IActionResult> Post([FromBody] CreateProjectRequest request)
         {
             var command = _mapper.Map<CreateProjectCommand>(request);
             var result = await _sender.Send(command);
-            return Ok(_mapper.Map<CreateProjectResult>(result));
+
+            if (result.IsSuccess)
+            {
+
+                var query = new GetProjectByIdQuery(result.Value);
+                var response = await _sender.Send(query);
+
+                return Ok(_mapper.Map<ProjectResponse>(response));
+
+            }
+            else {
+
+                return Ok(result);
+            
+            }
         
         }
 
         [HttpPost("AddAttachment")]
-        public async Task<IActionResult> AddAttachment( [FromForm]AddAttachmentRequest request)
+        public async Task<IActionResult> PostAddAttachment( [FromForm]AddAttachmentRequest request)
         {
             var command = _mapper.Map<AddAttachmentCommand>(request);
             var result = await _sender.Send(command);

PSManagement.Api/Controllers/Steps/StepsController.cs

@@ -51,8 +51,8 @@ namespace PSManagement.Api.Controllers.Steps
             return Ok(result);
         }
 
-        [HttpPost("{id}")]
-        public async Task<IActionResult> ChangeStepWeight(ChangeStepWeightRequest request,[FromRoute]int id)
+        [HttpPut("{id}")]
+        public async Task<IActionResult> PutChangeStepWeight(ChangeStepWeightRequest request,[FromRoute]int id)
         {
             if (request.StepId != id) {
                 return Ok(Result.NotFound("the step not found"));
@@ -75,9 +75,8 @@ namespace PSManagement.Api.Controllers.Steps
             return Ok(result);
         }
 
-
-        [HttpPost]
-        public async Task<IActionResult> UpdateCompleteionRatio(UpdateCompletionRatioRequest request)
+        [HttpPut]
+        public async Task<IActionResult> PutCompletionRatio(UpdateCompletionRatioRequest request)
         {
             var query = _mapper.Map<UpdateCompletionRatioCommand>(request);
 

PSManagement.Api/Controllers/Tracks/TracksController.cs

-using Microsoft.AspNetCore.Mvc;
+using Ardalis.Result;
+using AutoMapper;
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
 using PSManagement.Api.Controllers.ApiBase;
+using PSManagement.Application.Tracks.UseCaes.Commands.AddEmployeeTrack;
+using PSManagement.Application.Tracks.UseCaes.Commands.AddStepTrack;
+using PSManagement.Application.Tracks.UseCaes.Commands.CompleteTrack;
+using PSManagement.Application.Tracks.UseCaes.Commands.CreateTrack;
+using PSManagement.Application.Tracks.UseCaes.Commands.RemoveTrack;
+using PSManagement.Application.Tracks.UseCaes.Commands.UpdateEmployeeWorkTrack;
+using PSManagement.Application.Tracks.UseCaes.Commands.UpdateStepTrack;
+using PSManagement.Application.Tracks.UseCaes.Queries.GetEmployeesTrack;
+using PSManagement.Application.Tracks.UseCaes.Queries.GetStepsTrack;
+using PSManagement.Application.Tracks.UseCaes.Queries.GetTrackById;
+using PSManagement.Application.Tracks.UseCaes.Queries.GetTracksByProject;
+using PSManagement.Contracts.Tracks.Requests;
+using PSManagement.Contracts.Tracks.Response;
+using System.Collections.Generic;
+using System.Threading.Tasks;
 
 namespace PSManagement.Api.Controllers.Tracks
 {
     [Route("api/[controller]")]
     public class TracksController : APIController
     {
+
+        private readonly IMapper _mapper;
+        private readonly IMediator _sender;
+
+        public TracksController(IMediator sender, IMapper mapper)
+        {
+            _sender = sender;
+            _mapper = mapper;
+        }
+
+        [HttpGet("{id}")]
+        public async Task<IActionResult> Get(int id)
+        {
+            var query = new GetTrackByIdQuery(id);
+
+            var result = _mapper.Map<Result<TrackResponse>>(await _sender.Send(query));
+
+            return Ok(result);
+        }
+
+        [HttpGet("GetStepsTrack{id}")]
+        public async Task<IActionResult> GetStepsTrack([FromRoute]int id)
+        {
+            var query = new GetStepsTrackQuery(id);
+
+            var result = _mapper.Map<Result<IEnumerable<StepTrackResponse>>>(await _sender.Send(query));
+
+            return Ok(result);
+        }
+
+        [HttpGet("GetEmployeesTrack{id}")]
+        public async Task<IActionResult> GetEmployeesTrack([FromRoute] int id)
+        {
+            var query = new GetEmployeesTrackQuery(id);
+
+            var result = _mapper.Map<Result<IEnumerable<EmployeeTrackResponse>>>(await _sender.Send(query));
+
+            return Ok(result);
+
+        }
+
+        [HttpGet("GetTracksByProject")]
+        public async Task<IActionResult> GetTracksByProject(GetTracksByProjectRequest request)
+        {
+            var query = _mapper.Map<GetTracksByProjectQuery>(request);
+
+            var result = _mapper.Map<Result<IEnumerable<TrackResponse>>>(await _sender.Send(query));
+
+            return Ok(result);
+        }
+
+        [HttpPost("AddStepTrack")]
+        public async Task<IActionResult>PostStepTrack(AddStepTrackRequest request)
+        {
+            var command = _mapper.Map<AddStepTrackCommand>(request);
+
+            var result = _mapper.Map<Result<int>>(await _sender.Send(command));
+
+            return Ok(result);
+        }
+
+        [HttpPost("AddEmployeeTrack")]
+        public async Task<IActionResult> PostEmployeeTrack(AddEmployeeTrackRequest request)
+        {
+            var command = _mapper.Map<AddEmployeeTrackCommand>(request);
+
+            var result = _mapper.Map<Result<int>>(await _sender.Send(command));
+
+            return Ok(result);
+        }
+
+        [HttpPost("CompleteTrack")]
+        public async Task<IActionResult> PostCompleteTrack(CompleteTrackRequest request)
+        {
+            var command = _mapper.Map<CompleteTrackCommand>(request);
+
+            var result = _mapper.Map<Result>(await _sender.Send(command));
+
+            return Ok(result);
+        }
+
+        [HttpPost("RemoveTrack")]
+        public async Task<IActionResult> PostRemoveTrack(RemoveTrackRequest request)
+        {
+            var command = _mapper.Map<RemoveTrackCommand>(request);
+
+            var result = _mapper.Map<Result>(await _sender.Send(command));
+
+            return Ok(result);
+        }
+
+        [HttpPost]
+        public async Task<IActionResult> PostCreateTrack(CreateTrackRequest request)
+        {
+            var command = _mapper.Map<CreateTrackCommand>(request);
+
+            var result = _mapper.Map<Result<int>>(await _sender.Send(command));
+
+            if (result.IsSuccess)
+            {
+
+                var query = new GetTrackByIdQuery(result.Value);
+                var response = await _sender.Send(query);
+
+                return Ok(_mapper.Map<TrackResponse>(response));
+
+            }
+            else
+            {
+
+                return Ok(result);
+
+            }
+        }
+
+        [HttpPut("UpdateEmployeeWorkTrack")]
+        public async Task<IActionResult> PutEmployeeWorkTrack(UpdateEmployeeWorkTrackRequest request)
+        {
+            var command = _mapper.Map<UpdateEmployeeWorkTrackCommand>(request);
+
+            var result = _mapper.Map<Result>(await _sender.Send(command));
+
+            return Ok(result);
+        }
+        [HttpPut("UpdateStepTrack")]
+        public async Task<IActionResult> PutStepTrack(UpdateStepTrackRequest request)
+        {
+            var command = _mapper.Map<UpdateStepTrackCommand>(request);
+
+            var result = _mapper.Map<Result>(await _sender.Send(command));
+
+            return Ok(result);
+        }
+
+
     }
 }

PSManagement.Application/ApplicationDTOsMappers/MapperConfiguration.cs

@@ -28,7 +28,8 @@ namespace PSManagement.Application.Mappers
             CreateMap<CustomerDTO, Customer>().ReverseMap();
             CreateMap<ContactInfoDTO, ContactInfo>().ReverseMap();
 
-            CreateMap<StepDTO, Step>().ReverseMap();
+            CreateMap<Step, StepDTO>()
+             ;
 
             CreateMap<Employee, EmployeeDTO>()
                 .ForMember(e => e.DepartmentName, op => op.MapFrom(e => e.Department.Name));
@@ -39,13 +40,18 @@ namespace PSManagement.Application.Mappers
                 .ForMember(d => d.Employee, op => op.MapFrom(e => e.Employee))
                 
                 ;
+            CreateMap<StepTrack, StepTrackDTO>()
+                .ForMember(d => d.StepInfo, opt => opt.MapFrom(s => s.Step.StepInfo))
+                .ForMember(d => d.TrackInfo, op => op.MapFrom(e => e.Track.TrackInfo))
+                ;
+            CreateMap<EmployeeTrack, EmployeeTrackDTO>()
+                .ForMember(d => d.TrackInfo, op => op.MapFrom(e => e.Track.TrackInfo))
+                ;
 
             CreateMap<Project, ProjectInfo>()
                 .ConvertUsing(project => project.ProjectInfo);
 
-            CreateMap<TrackDTO, Track>().ReverseMap();
-            CreateMap<StepTrack, StepTrackDTO>()
-                .ForMember(d => d.TrackDate, op=> op.MapFrom( src => src.Track.TrackInfo.TrackDate));
+            CreateMap<Track, TrackDTO>();
 
             CreateMap<FinancialSpendingDTO, FinancialSpending>().ReverseMap();
            

PSManagement.Application/Employees/UseCases/Queries/GetEmployeeTrackHistory/GetEmployeeTrackHistoryQuery.cs

+using Ardalis.Result;
+using PSManagement.Application.Tracks.Common;
+using PSManagement.Domain.Projects;
+using PSManagement.Domain.Projects.Repositories;
+using PSManagement.SharedKernel.CQRS.Query;
+using System.Collections.Generic;
+
+namespace PSManagement.Application.Employees.UseCases.Queries.GetEmployeeTrackHistory
+{
+    public record GetEmployeeTrackHistoryQuery(
+        int EmployeeId,
+        int ProjectId,
+        int? PageNumber,
+        int? PageSize
+    ) : IQuery<Result<IEnumerable<EmployeeTrackDTO>>>;
+}

PSManagement.Application/Employees/UseCases/Queries/GetEmployeeTrackHistory/GetEmployeeTrackHistoryQueryHandler.cs

+using Ardalis.Result;
+using AutoMapper;
+using PSManagement.Application.Tracks.Common;
+using PSManagement.Domain.Tracking;
+using PSManagement.Domain.Tracking.Specification;
+using PSManagement.SharedKernel.CQRS.Query;
+using PSManagement.SharedKernel.Repositories;
+using PSManagement.SharedKernel.Specification;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace PSManagement.Application.Employees.UseCases.Queries.GetEmployeeTrackHistory
+{
+    public class GetEmployeeTrackHistoryQueryHandler : IQueryHandler<GetEmployeeTrackHistoryQuery, Result<IEnumerable<EmployeeTrackDTO>>>
+    {
+        private readonly IRepository<EmployeeTrack> _employeeTracksRepository;
+        private readonly BaseSpecification<EmployeeTrack> _specification;
+        private readonly IMapper _mapper;
+
+        public GetEmployeeTrackHistoryQueryHandler(
+            IMapper mapper,
+            IRepository<EmployeeTrack> employeeTracksRepository)
+        {
+            _specification = new EmployeeTrackSpecification();
+            _mapper = mapper;
+            _employeeTracksRepository = employeeTracksRepository;
+        }
+
+        public async Task<Result<IEnumerable<EmployeeTrackDTO>>> Handle(GetEmployeeTrackHistoryQuery 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.Track);
+            _specification.AddInclude(e => e.Employee);
+            _specification.Criteria = e => e.EmloyeeId == request.EmployeeId  && e.Track.ProjectId == request.ProjectId;
+            _specification.ApplyPaging((pageNumber - 1) * pageSize, pageSize);
+
+            IEnumerable<EmployeeTrack> employeeTracks = await _employeeTracksRepository.ListAsync( _specification);
+
+            return Result.Success(_mapper.Map<IEnumerable<EmployeeTrackDTO>>(employeeTracks));
+        }
+    }
+}

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

@@ -9,7 +9,9 @@ namespace PSManagement.Application.Employees.UseCases.Queries.GetEmployeesByFilt
          string EmployeeFirstName,
          int? HiastId,
          string DepartmentName,
-         string WorkType
+         string WorkType,
+         int? PageNumber,
+         int? PageSize
     ) : IQuery<Result<IEnumerable<EmployeeDTO>>>;
 
 }

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

@@ -29,6 +29,10 @@ namespace PSManagement.Application.Employees.UseCases.Queries.GetEmployeesByFilt
 
         public async Task<Result<IEnumerable<EmployeeDTO>>> Handle(GetEmployeesByFilterQuery 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);
 
             IEnumerable<Employee> employees =await _employeesRepository.ListAsync(_specification);

PSManagement.Application/PSManagement.Application.csproj

@@ -7,12 +7,8 @@
 
   <ItemGroup>
     <Folder Include="Behaviors\AuthorizationBehavior\" />
-    <Folder Include="Employees\UseCases\Commands\IncreasEmployeeWorkHours\" />
-    <Folder Include="Projects\UseCases\Queries\GetProjectAttachments\" />
-    <Folder Include="Tracks\UseCaes\Commands\UpdateEmployeeTrack\" />
-    <Folder Include="Tracks\UseCaes\Commands\UpdateStepTrack\" />
-    <Folder Include="Tracks\UseCaes\Queries\GetEmployeesTrack\" />
-    <Folder Include="Employees\UseCases\Queries\GetEmployeeTrackHistory\" />
+    <Folder Include="Customers\UseCases\Commands\RemoveContactInfo\" />
+    <Folder Include="Tracks\EventsHandlers\" />
   </ItemGroup>
 
   <ItemGroup>

PSManagement.Application/Projects/Common/AttachmentDTO.cs

+namespace PSManagement.Application.Projects.Common
+{
+    public class AttachmentDTO
+    {
+        public int Id { get; set; }
+        public int ProjectId { get; set; }
+        public string AttachmentUrl { get; set; }
+        public string AttachmentName { get; set; }
+        public string AttachmentDescription { get; set; }
+    }
+}
\ No newline at end of file

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

@@ -18,5 +18,5 @@ namespace PSManagement.Application.Projects.UseCases.Commands.CreateProject
         int ProjectManagerId,
         int ProposerId,
         int ExecuterId
-        ) : ILoggableCommand<Result<CreateProjectResult>>;
+        ) : ILoggableCommand<Result<int>>;
 }

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

@@ -11,7 +11,7 @@ using System.Threading.Tasks;
 
 namespace PSManagement.Application.Projects.UseCases.Commands.CreateProject
 {
-    public class CreateProjectCommandHandler : ICommandHandler<CreateProjectCommand, Result<CreateProjectResult>>
+    public class CreateProjectCommandHandler : ICommandHandler<CreateProjectCommand, Result<int>>
     {
         private readonly IProjectsRepository _projectsRepository;
         private readonly ProjectBuilder _projectBuilder;
@@ -28,7 +28,7 @@ namespace PSManagement.Application.Projects.UseCases.Commands.CreateProject
             _unitOfWork = unitOfWork;
         }
 
-        public async Task<Result<CreateProjectResult>> Handle(CreateProjectCommand request, CancellationToken cancellationToken)
+        public async Task<Result<int>> Handle(CreateProjectCommand request, CancellationToken cancellationToken)
         {
             Project project = _projectBuilder
                 .WithProjectAggreement(request.ProjectAggreement)
@@ -56,7 +56,7 @@ namespace PSManagement.Application.Projects.UseCases.Commands.CreateProject
 
             project.AddDomainEvent(new ProjectCreatedEvent(project.Id,project.TeamLeaderId,project.ProjectManagerId));
             await _unitOfWork.SaveChangesAsync();
-            return Result.Success(response);
+            return Result.Success(response.ProjectId);
 
         }
     }

PSManagement.Application/Projects/UseCases/Queries/GetProjectAttachments/GetProjectAttachmentQuery.cs

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

PSManagement.Application/Projects/UseCases/Queries/GetProjectAttachments/GetProjectAttachmentsQueryHandler.cs

+using Ardalis.Result;
+using AutoMapper;
+using PSManagement.Application.Projects.Common;
+using PSManagement.Domain.Projects.Entities;
+using PSManagement.SharedKernel.CQRS.Query;
+using PSManagement.SharedKernel.Repositories;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace PSManagement.Application.Projects.UseCases.Queries.GetProjectAttachments
+{
+    public class GetProjectAttachmentsQueryHandler : IQueryHandler<GetProjectAttachmentsQuery, Result<IEnumerable<AttachmentDTO>>>
+    {
+        private readonly IRepository<Attachment> _attachmentRepository;
+
+        private readonly IMapper _mapper;
+
+        public GetProjectAttachmentsQueryHandler(
+            IMapper mapper,
+            IRepository<Attachment> attachmentRepository)
+        {
+            _mapper = mapper;
+            _attachmentRepository = attachmentRepository;
+        }
+
+        public async Task<Result<IEnumerable<AttachmentDTO>>> Handle(GetProjectAttachmentsQuery 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;
+
+
+            var attachments = await _attachmentRepository.ListAsync();
+            attachments = attachments.Where(e => e.ProjectId == request.ProjectId).Skip((pageNumber - 1) * pageSize).Take(pageSize);
+
+            return Result.Success(_mapper.Map<IEnumerable<AttachmentDTO>>(attachments));
+        }
+    }
+}

PSManagement.Application/Steps/UseCases/Queries/GetStepTrackHistory/GetStepTrackHistoryQueryHandler.cs

@@ -35,12 +35,9 @@ namespace PSManagement.Application.Steps.UseCases.Queries.GetStepTrackHistory
             _specification.AddInclude("StepTracks.Track");
             
 
-
-            _specification.ApplyPaging((pageNumber - 1) * pageSize, pageSize);
-
             var steps = await _stepsRepository.GetByIdAsync(request.StepId,_specification);
 
-            return Result.Success(_mapper.Map<IEnumerable<StepTrackDTO>>(steps.StepTracks.AsEnumerable()));
+            return Result.Success(_mapper.Map<IEnumerable<StepTrackDTO>>(steps.StepTracks.AsEnumerable().Skip((pageNumber - 1) * pageSize).Take(pageSize)));
         }
     }
 }

PSManagement.Application/Tracks/Common/EmployeeTrackDTO.cs

@@ -4,6 +4,7 @@ namespace PSManagement.Application.Tracks.Common
 {
     public class EmployeeTrackDTO
     {
+        public int Id { get; set; }
         public int EmloyeeId { get; set; }
         public int TrackId { get; set; }
         public TrackInfo TrackInfo { get; set; }

PSManagement.Application/Tracks/Common/StepTrackDTO.cs

@@ -7,6 +7,7 @@ namespace PSManagement.Application.Tracks.Common
 {
     public class StepTrackDTO
     {
+        public int Id { get; set; }
         public int StepId { get; set; }
         public int TrackId { get; set; }
         public StepInfo StepInfo { get; set; }
@@ -14,7 +15,6 @@ namespace PSManagement.Application.Tracks.Common
         public TrackInfo TrackInfo { get; set; }
 
         public String ExecutionState { get; set; }
-        public DateTime TrackDate { get; set; }
         public int ExecutionRatio { get; set; }
 
     }

PSManagement.Application/Tracks/Common/TrackDTO.cs

@@ -11,7 +11,6 @@ namespace PSManagement.Application.Tracks.Common
     public class TrackDTO
     {
         public int Id { get; set; }
-        public bool IsCompleted { get; set; }
         public TrackInfo TrackInfo { get; set; }
         public String Notes { get; set; }
         public int ProjectId { get; set; }

PSManagement.Application/Tracks/UseCaes/Commands/AddEmployeeTrack/AddEmployeeTrackCommandHandler.cs

@@ -3,11 +3,14 @@ using AutoMapper;
 using PSManagement.Domain.Steps.Repositories;
 using PSManagement.Domain.Tracking;
 using PSManagement.Domain.Tracking.DomainErrors;
+using PSManagement.Domain.Tracking.Specification;
 using PSManagement.SharedKernel.CQRS.Command;
 using PSManagement.SharedKernel.Interfaces;
 using PSManagement.SharedKernel.Repositories;
+using PSManagement.SharedKernel.Specification;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Linq;
 
 namespace PSManagement.Application.Tracks.UseCaes.Commands.AddEmployeeTrack
 {
@@ -17,6 +20,7 @@ namespace PSManagement.Application.Tracks.UseCaes.Commands.AddEmployeeTrack
         private readonly ITracksRepository _tracksRepository;
         private readonly IUnitOfWork _unitOfWork;
         private readonly IMapper _mapper;
+        private readonly BaseSpecification<Track> _specification;
 
         public AddEmployeeTrackCommandHandler(
             IUnitOfWork unitOfWork,
@@ -28,11 +32,13 @@ namespace PSManagement.Application.Tracks.UseCaes.Commands.AddEmployeeTrack
             _tracksRepository = tracksRepository;
             _employeeTracksRepository = employeeTracksRepository;
             _mapper = mapper;
+            _specification = new TrackSpecification();
         }
 
         public async Task<Result<int>> Handle(AddEmployeeTrackCommand request, CancellationToken cancellationToken)
         {
-            Track track = await _tracksRepository.GetByIdAsync(request.TrackId);
+            _specification.AddInclude(e => e.EmployeeTracks);
+            Track track = await _tracksRepository.GetByIdAsync(request.TrackId,_specification);
 
             if (track is null)
             {
@@ -41,6 +47,18 @@ namespace PSManagement.Application.Tracks.UseCaes.Commands.AddEmployeeTrack
 
             }
 
+            if (track.TrackInfo.IsCompleted)
+            {
+
+                return Result.Invalid(TracksErrors.TrackCompletedUpdateError);
+            }
+
+            if (track.EmployeeTracks.Any(e => e.EmloyeeId == request.EmployeeId)) {
+
+                return Result.Invalid(TracksErrors.ParticipantTrackExistError);
+            
+            }
+
             EmployeeTrack employeeTrack = await _employeeTracksRepository.AddAsync(_mapper.Map<EmployeeTrack>(request));
 
             await _unitOfWork.SaveChangesAsync();

PSManagement.Application/Tracks/UseCaes/Commands/AddStepTrack/AddStepTrackCommandHandler.cs

@@ -4,9 +4,12 @@ using PSManagement.Domain.Steps.Repositories;
 using PSManagement.Domain.Tracking;
 using PSManagement.Domain.Tracking.DomainErrors;
 using PSManagement.Domain.Tracking.Entities;
+using PSManagement.Domain.Tracking.Specification;
 using PSManagement.SharedKernel.CQRS.Command;
 using PSManagement.SharedKernel.Interfaces;
 using PSManagement.SharedKernel.Repositories;
+using PSManagement.SharedKernel.Specification;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -18,6 +21,7 @@ namespace PSManagement.Application.Tracks.UseCaes.Commands.AddStepTrack
         private readonly ITracksRepository _tracksRepository;
         private readonly IUnitOfWork _unitOfWork;
         private readonly IMapper _mapper;
+        private readonly BaseSpecification<Track> _specification;
 
         public AddStepTrackCommandHandler(
             IUnitOfWork unitOfWork,
@@ -29,17 +33,31 @@ namespace PSManagement.Application.Tracks.UseCaes.Commands.AddStepTrack
             _tracksRepository = tracksRepository;
             _stepTracksRepository = stepTracksRepository;
             _mapper = mapper;
+            _specification = new TrackSpecification();
         }
 
         public async Task<Result<int>> Handle(AddStepTrackCommand request, CancellationToken cancellationToken)
         {
-            Track track = await _tracksRepository.GetByIdAsync(request.TrackId);
+            _specification.AddInclude(e => e.StepTracks);
+            Track track = await _tracksRepository.GetByIdAsync(request.TrackId,_specification);
 
             if (track is null)
             {
 
                 return Result.Invalid(TracksErrors.InvalidEntryError);
 
+            }
+            if (track.TrackInfo.IsCompleted)
+            {
+
+                return Result.Invalid(TracksErrors.TrackCompletedUpdateError);
+            }
+
+            if (track.StepTracks.Any(e => e.StepId == request.StepId))
+            {
+
+                return Result.Invalid(TracksErrors.StepTrackExistError);
+
             }
 
             StepTrack stepTrack = await _stepTracksRepository.AddAsync(_mapper.Map<StepTrack>(request));

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

+using Ardalis.Result;
+using PSManagement.Domain.Tracking.ValueObjects;
+using PSManagement.SharedKernel.CQRS.Command;
+
+namespace PSManagement.Application.Tracks.UseCaes.Commands.UpdateEmployeeWorkTrack
+{
+    public record UpdateEmployeeWorkTrackCommand(
+        int EmployeeTrackId,
+        int TrackId,
+        int EmployeeId,
+        EmployeeWorkInfo EmployeeWorkInfo,
+        EmployeeWork EmployeeWork,
+        string Notes
+     ) : ILoggableCommand<Result>;
+}

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

+using Ardalis.Result;
+using AutoMapper;
+using PSManagement.Domain.Steps.Repositories;
+using PSManagement.Domain.Tracking;
+using PSManagement.Domain.Tracking.DomainErrors;
+using PSManagement.SharedKernel.CQRS.Command;
+using PSManagement.SharedKernel.Interfaces;
+using PSManagement.SharedKernel.Repositories;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace PSManagement.Application.Tracks.UseCaes.Commands.UpdateEmployeeWorkTrack
+{
+    public class UpdateEmployeeWorkTrackCommandHandler : ICommandHandler<UpdateEmployeeWorkTrackCommand, Result>
+    {
+        private readonly IRepository<EmployeeTrack> _employeeTracksRepository;
+        private readonly ITracksRepository _tracksRepository;
+        private readonly IUnitOfWork _unitOfWork;
+        private readonly IMapper _mapper;
+
+        public UpdateEmployeeWorkTrackCommandHandler(
+            IUnitOfWork unitOfWork,
+            ITracksRepository tracksRepository,
+            IRepository<EmployeeTrack> employeeTracksRepository,
+            IMapper mapper)
+        {
+            _unitOfWork = unitOfWork;
+            _tracksRepository = tracksRepository;
+            _employeeTracksRepository = employeeTracksRepository;
+            _mapper = mapper;
+        }
+
+        public async Task<Result> Handle(UpdateEmployeeWorkTrackCommand request, CancellationToken cancellationToken)
+        {
+            Track track = await _tracksRepository.GetByIdAsync(request.TrackId);
+
+            if (track is null)
+            {
+
+                return Result.Invalid(TracksErrors.InvalidEntryError);
+
+            }
+            if (track.TrackInfo.IsCompleted)
+            {
+
+                return Result.Invalid(TracksErrors.TrackCompletedUpdateError);
+            }
+            EmployeeTrack employeeTrack = await _employeeTracksRepository.GetByIdAsync(request.EmployeeTrackId);
+            if (employeeTrack is null)
+            {
+
+                return Result.Invalid(TracksErrors.InvalidEntryError);
+
+            }
+            if (request.EmployeeId != employeeTrack.EmloyeeId)
+            {
+
+                return Result.Invalid(TracksErrors.InvalidEntryError);
+            }
+
+            employeeTrack.EmployeeWork = request.EmployeeWork;
+            employeeTrack.EmployeeWorkInfo = request.EmployeeWorkInfo;
+            employeeTrack.Notes = request.Notes;
+
+            await _employeeTracksRepository.UpdateAsync(employeeTrack);
+
+            return Result.Success();
+
+        }
+    }
+}

PSManagement.Application/Tracks/UseCaes/Commands/UpdateStepTrack/UpdateStepTrackCommand.cs

+using Ardalis.Result;
+using PSManagement.SharedKernel.CQRS.Command;
+using System;
+
+namespace PSManagement.Application.Tracks.UseCaes.Commands.UpdateStepTrack
+{
+    public record UpdateStepTrackCommand(
+        int StepTrackId,
+        int TrackId,
+        int StepId,
+        string ExecutionState,
+        DateTime TrackDate,
+        int ExecutionRatio
+     ) : ILoggableCommand<Result>;
+
+}

PSManagement.Application/Tracks/UseCaes/Commands/UpdateStepTrack/UpdateStepTrackCommandHandler.cs

+using Ardalis.Result;
+using AutoMapper;
+using PSManagement.Domain.Steps.Repositories;
+using PSManagement.Domain.Tracking;
+using PSManagement.Domain.Tracking.DomainErrors;
+using PSManagement.Domain.Tracking.Entities;
+using PSManagement.SharedKernel.CQRS.Command;
+using PSManagement.SharedKernel.Interfaces;
+using PSManagement.SharedKernel.Repositories;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace PSManagement.Application.Tracks.UseCaes.Commands.UpdateStepTrack
+{
+    public class UpdateStepTrackCommandHandler : ICommandHandler<UpdateStepTrackCommand, Result>
+    {
+        private readonly IRepository<StepTrack> _stepTracksRepository;
+        private readonly ITracksRepository _tracksRepository;
+        private readonly IUnitOfWork _unitOfWork;
+        private readonly IMapper _mapper;
+
+        public UpdateStepTrackCommandHandler(
+            IUnitOfWork unitOfWork,
+            ITracksRepository tracksRepository,
+            IRepository<StepTrack> stepTracksRepository,
+            IMapper mapper)
+        {
+            _unitOfWork = unitOfWork;
+            _tracksRepository = tracksRepository;
+            _stepTracksRepository = stepTracksRepository;
+            _mapper = mapper;
+        }
+
+        public async Task<Result> Handle(UpdateStepTrackCommand request, CancellationToken cancellationToken)
+        {
+            Track track = await _tracksRepository.GetByIdAsync(request.TrackId);
+
+            if (track is null)
+            {
+
+                return Result.Invalid(TracksErrors.InvalidEntryError);
+
+            }
+            if (track.TrackInfo.IsCompleted)
+            {
+
+                return Result.Invalid(TracksErrors.TrackCompletedUpdateError);
+            }
+
+            StepTrack stepTrack = await _stepTracksRepository.GetByIdAsync(request.StepTrackId);
+            if (stepTrack is null)
+            {
+
+                return Result.Invalid(TracksErrors.InvalidEntryError);
+
+            }
+            if (request.StepId != stepTrack.StepId)
+            {
+
+                return Result.Invalid(TracksErrors.InvalidEntryError);
+            }
+
+            stepTrack.ExecutionRatio = request.ExecutionRatio;
+            stepTrack.ExecutionState = request.ExecutionState;
+
+            await _stepTracksRepository.UpdateAsync(stepTrack);
+
+            return Result.Success();
+
+        }
+    }
+
+}

PSManagement.Application/Tracks/UseCaes/Queries/GetEmployeesTrack/GetEmployeesTrackQuery.cs

+using Ardalis.Result;
+using PSManagement.Application.Tracks.Common;
+using PSManagement.SharedKernel.CQRS.Query;
+using System.Collections.Generic;
+
+namespace PSManagement.Application.Tracks.UseCaes.Queries.GetEmployeesTrack
+{
+    public record GetEmployeesTrackQuery(
+        int TrackId
+    ) : IQuery<Result<IEnumerable<EmployeeTrackDTO>>>;
+}

PSManagement.Application/Tracks/UseCaes/Queries/GetEmployeesTrack/GetEmployeesTrackQueryHandler.cs

+using Ardalis.Result;
+using AutoMapper;
+using PSManagement.Application.Tracks.Common;
+using PSManagement.Domain.Steps.Repositories;
+using PSManagement.Domain.Tracking;
+using PSManagement.Domain.Tracking.DomainErrors;
+using PSManagement.Domain.Tracking.Specification;
+using PSManagement.SharedKernel.CQRS.Query;
+using PSManagement.SharedKernel.Repositories;
+using PSManagement.SharedKernel.Specification;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace PSManagement.Application.Tracks.UseCaes.Queries.GetEmployeesTrack
+{
+    public class GetEmployeesTrackQueryHandler : IQueryHandler<GetEmployeesTrackQuery, Result<IEnumerable<EmployeeTrackDTO>>>
+    {
+        private readonly ITracksRepository _tracksRepository;
+        private readonly IRepository<EmployeeTrack> _employeeTracksRepository;
+        private readonly IMapper _mapper;
+        private readonly BaseSpecification<EmployeeTrack> _specification;
+        public GetEmployeesTrackQueryHandler(
+            IMapper mapper,
+            ITracksRepository tracksRepository,
+            IRepository<EmployeeTrack> employeeTracksRepository
+            )
+        {
+            _mapper = mapper;
+            _tracksRepository = tracksRepository;
+            _specification = new EmployeeTrackSpecification();
+            _employeeTracksRepository = employeeTracksRepository;
+        }
+
+
+        public async Task<Result<IEnumerable<EmployeeTrackDTO>>> Handle(GetEmployeesTrackQuery request, CancellationToken cancellationToken)
+        {
+
+
+
+            _specification.Criteria = t => t.TrackId == request.TrackId;
+            _specification.AddInclude(e => e.Employee);
+
+
+            var track = await _tracksRepository.GetByIdAsync(request.TrackId);
+            if (track is null)
+            {
+                return Result.Invalid(TracksErrors.InvalidEntryError);
+            }
+            else
+            {
+
+                IEnumerable<EmployeeTrack> employeeTracks = await _employeeTracksRepository.ListAsync(_specification);
+                employeeTracks = employeeTracks.Select(eTrack => { eTrack.Track = track; return eTrack; });
+
+                return Result.Success(_mapper.Map<IEnumerable<EmployeeTrackDTO>>(employeeTracks));
+
+            }
+
+        }
+    }
+}

PSManagement.Application/Tracks/UseCaes/Queries/GetStepsTrack/GetStepsTrackQuery.cs

@@ -8,4 +8,5 @@ namespace PSManagement.Application.Tracks.UseCaes.Queries.GetStepsTrack
     public record GetStepsTrackQuery(
         int TrackId
     ) : IQuery<Result<IEnumerable<StepTrackDTO>>>;
+
 }

PSManagement.Contracts/Employees/Requests/GetAvailableEmployeesRequest.cs

@@ -3,5 +3,4 @@
     public record GetAvailableEmployeesRequest(
     int? PageNumber,
     int? PageSize);
-
 }

PSManagement.Contracts/Employees/Requests/GetEmployeeTrackHistoryRequest.cs

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

PSManagement.Contracts/Employees/Requests/GetEmployeesByFilterRequest.cs

@@ -4,6 +4,8 @@
      string EmployeeFirstName,
      int? HiastId,
      string DepartmentName,
-     string WorkType
+     string WorkType,
+     int? PageSize ,
+     int? PageNumber
      ) ;
 }

PSManagement.Contracts/PSManagement.Contracts.csproj

@@ -15,9 +15,4 @@
     <ProjectReference Include="..\PSManagement.SharedKernel\PSManagement.SharedKernel.csproj" />
   </ItemGroup>
 
-  <ItemGroup>
-    <Folder Include="Tracks\Response\" />
-    <Folder Include="Tracks\Requests\" />
-  </ItemGroup>
-
 </Project>

PSManagement.Contracts/Projects/Requests/GetProjectsByFilterRequest.cs

@@ -4,7 +4,7 @@
      string ProjectName,
      string TeamLeaderName,
      string DepartmentName,
-     string ProposerName
- );
-
+     string ProposerName,
+     int? PageNumber,
+     int? PagerSize);
 }

PSManagement.Contracts/Projects/Requests/GetProjectsByProjectManagerRequest.cs

+namespace PSManagement.Contracts.Projects.Requests
+{
+    public record GetProjectsByProjectManagerRequest(
+    int ProjectManager,
+    int? PageNumber ,
+    int? PageSize
+    );
+}

PSManagement.Contracts/Projects/Response/AttachmentReponse.cs

+namespace PSManagement.Contracts.Projects.Response
+{
+    public record AttachmentReponse(
+        int Id ,
+        int ProjectId,
+        string AttachmentUrl ,
+        string AttachmentName ,
+        string AttachmentDescription 
+    );
+
+}

PSManagement.Contracts/Tracks/Requests/AddEmployeeTrackRequest.cs

+using PSManagement.Domain.Tracking.ValueObjects;
+
+namespace PSManagement.Contracts.Tracks.Requests
+{
+    public record AddEmployeeTrackRequest(
+        int TrackId,
+        int EmployeeId,
+        EmployeeWorkInfo EmployeeWorkInfo,
+        EmployeeWork EmployeeWork,
+        string Notes,
+        int ProjectId
+    ) ;
+}

PSManagement.Contracts/Tracks/Requests/AddStepTrackRequest.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PSManagement.Contracts.Tracks.Requests
+{
+    public record AddStepTrackRequest(
+      int StepId,
+      int TrackId,
+      string ExecutionState,
+      DateTime TrackDate,
+      int ExecutionRatio
+  );
+}

PSManagement.Contracts/Tracks/Requests/CompleteTrackRequest.cs

+using System;
+
+namespace PSManagement.Contracts.Tracks.Requests
+{
+    public record CompleteTrackRequest(
+        int TrackId,
+        DateTime CompletionDate,
+        int ProjectId
+    ) ;
+}

PSManagement.Contracts/Tracks/Requests/CreateTrackRequest.cs

+using PSManagement.Domain.Tracking.ValueObjects;
+using System;
+
+namespace PSManagement.Contracts.Tracks.Requests
+{
+    public record CreateTrackRequest(
+        TrackInfo TrackInfo,
+        String Notes,
+        int ProjectId
+    );
+}

PSManagement.Contracts/Tracks/Requests/GetTracksByProjectRequest.cs

+namespace PSManagement.Contracts.Tracks.Requests
+{
+    public record GetTracksByProjectRequest(
+      int ProjectId,
+      int? PageNumber,
+      int? PageSize
+
+      );
+}

PSManagement.Contracts/Tracks/Requests/RemoveTrackRequest.cs

+namespace PSManagement.Contracts.Tracks.Requests
+{
+    public record RemoveTrackRequest(
+        int TrackId
+    );
+}

PSManagement.Contracts/Tracks/Requests/UpdateEmployeeWorkTrackRequest.cs

+using PSManagement.Domain.Tracking.ValueObjects;
+
+namespace PSManagement.Contracts.Tracks.Requests
+{
+    public record UpdateEmployeeWorkTrackRequest(
+          int EmployeeTrackId,
+          int TrackId,
+          int EmployeeId,
+          EmployeeWorkInfo EmployeeWorkInfo,
+          EmployeeWork EmployeeWork,
+          string Notes
+    );
+}

PSManagement.Contracts/Tracks/Requests/UpdateStepTrackRequest.cs

+using System;
+
+namespace PSManagement.Contracts.Tracks.Requests
+{
+    public record UpdateStepTrackRequest(
+      int StepTrackId,
+      int TrackId,
+      int StepId,
+      string ExecutionState,
+      DateTime TrackDate,
+      int ExecutionRatio
+   );
+}

PSManagement.Contracts/Tracks/Response/EmployeeTrackResponse.cs

+using PSManagement.Domain.Tracking.ValueObjects;
+
+namespace PSManagement.Contracts.Tracks.Response
+{
+    public record EmployeeTrackResponse(
+        int EmloyeeId,
+        int TrackId,
+        TrackInfo TrackInfo,
+        EmployeeWorkInfo EmployeeWorkInfo,
+        EmployeeWork EmployeeWork,
+        string Notes
+    );
+}

PSManagement.Contracts/Tracks/Response/StepTrackResponse.cs

+using PSManagement.Domain.Projects.ValueObjects;
+using PSManagement.Domain.Tracking.ValueObjects;
+using System;
+
+namespace PSManagement.Contracts.Tracks.Response
+{
+    public record StepTrackResponse(
+        int Id,
+        int StepId ,
+        int TrackId ,
+        StepInfo StepInfo ,
+        TrackInfo TrackInfo,
+        String ExecutionState,
+        DateTime TrackDate ,
+        int ExecutionRatio 
+    );
+}

PSManagement.Contracts/Tracks/Response/TrackResponse.cs

+using PSManagement.Domain.Tracking.ValueObjects;
+using System;
+
+namespace PSManagement.Contracts.Tracks.Response
+{
+    public record TrackResponse (
+        int Id ,
+        bool IsCompleted ,
+        TrackInfo TrackInfo ,
+        String Notes ,
+        int ProjectId 
+        );
+}

PSManagement.Domain/Tracking/DomainErrors/TracksErrors.cs

@@ -10,6 +10,11 @@ namespace PSManagement.Domain.Tracking.DomainErrors
     public class TracksErrors
     {
         public static DomainError InvalidEntryError { get; } = new("TrackError.InvalidEntry.", "Invalid Project Data");
+        public static DomainError ParticipantTrackExistError { get; } = new("TrackError.Participant.Exist.", "the Project already have the given particpant Data");
+        public static DomainError ParticipantTrackUnExistError { get; } = new("TrackError.Participant.UnExist.", "the Project doesnt have the given particpant Data");
+        public static DomainError StepTrackExistError { get; } = new("TrackError.Step.Exist.", "the Project already have the given particpant Data");
+        public static DomainError StepTrackUnExistError { get; } = new("TrackError.Step.UnExist.", "the Project doesnt have the given particpant Data");
+        public static DomainError TrackCompletedUpdateError { get; } = new("TrackError.Update.complete.", "the track couldnt be update afert its completed");
 
     }
 }

PSManagement.Domain/Tracking/Specification/EmployeeTrackSpecification.cs

+using PSManagement.SharedKernel.Specification;
+using System;
+using System.Linq.Expressions;
+
+namespace PSManagement.Domain.Tracking.Specification
+{
+    public class EmployeeTrackSpecification : BaseSpecification<EmployeeTrack>
+    {
+        public EmployeeTrackSpecification(Expression<Func<EmployeeTrack, bool>> criteria = null) : base(criteria)
+        {
+
+
+        }
+    }
+}

PSManagement.Domain/Tracking/Specification/StepTrackSpecification.cs

@@ -13,5 +13,4 @@ namespace PSManagement.Domain.Tracking.Specification
 
         }
     }
-
 }