Commit dc822b12 authored by hasan khaddour's avatar hasan khaddour

Implement CQRS for project domain

parent 9c065223
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
}
}
}
......@@ -26,7 +26,7 @@ namespace PSManagement.Application.DI
services.AddValidatorsFromAssembly(Assembly.GetExecutingAssembly());
services.AddAutoMapper(typeof(CustomerMapperConfiguration));
services.AddAutoMapper(typeof(Mappers.MapperConfiguration));
return services;
}
......
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; }
}
}
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; }
}
}
......@@ -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\" />
......
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
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
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>;
}
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();
}
}
}
}
}
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>>;
}
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);
}
}
}
}
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>;
}
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();
}
}
}
}
using Ardalis.Result;
using PSManagement.SharedKernel.CQRS.Command;
namespace PSManagement.Application.Projects.UseCases.Commands.CancelProject
{
public record CancelProjectCommand(
int EmployeeId,
int ProjectId
) : ICommand<Result>;
}
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();
}
}
}
}
using Ardalis.Result;
using PSManagement.SharedKernel.CQRS.Command;
namespace PSManagement.Application.Projects.UseCases.Commands.ChangeProjectTeamLeader
{
public record ChangeProjectTeamLeaderCommand(
int EmployeeId,
int ProjectId
) : ICommand<Result>;
}
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();
}
}
}
}
using Ardalis.Result;
using PSManagement.SharedKernel.CQRS.Command;
namespace PSManagement.Application.Projects.UseCases.Commands.CompletePlaningProject
{
public record CompletePlaningProjectCommand(
int ProjectId
) : ICommand<Result>;
}
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();
}
}
}
}
using Ardalis.Result;
using PSManagement.SharedKernel.CQRS.Command;
namespace PSManagement.Application.Projects.UseCases.Commands.CompleteProgressProject
{
public record CompleteProgressProjectCommand(
int ProjectId
) : ICommand<Result>;
}
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();
}
}
}
}
......@@ -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);
......
using Ardalis.Result;
using PSManagement.SharedKernel.CQRS.Command;
namespace PSManagement.Application.Projects.UseCases.Commands.RemoveParticipant
{
public record RemoveParticipantCommand(
int ProjectId,
int ParticipantId
) : ICommand<Result>;
}
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();
}
}
}
}
}
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>>>;
}
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);
}
}
}
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>>;
}
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);
}
}
}
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>>>;
}
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));
}
}
}
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
namespace PSManagement.Application.Tracks.Common
{
public class EmployeeTrackDTO
{
}
}
\ No newline at end of file
namespace PSManagement.Application.Tracks.Common
{
public class StepTrackDTO
{
}
}
\ No newline at end of file
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; }
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment