Merge pull request #750 from fossa-app/employee-reports-to

Employee reports to

Author: tiksn

src/API.Core/Entities/EmployeeEntity.cs

@@ -9,6 +9,7 @@ public record EmployeeEntity(
     CompanyId CompanyId,
     Option<BranchId> AssignedBranchId,
     Option<DepartmentId> AssignedDepartmentId,
+    Option<EmployeeId> ReportsToId,
     string FirstName,
     string LastName,
     string FullName)

src/API.Core/Messages/Commands/EmployeeCreationCommandHandler.cs

@@ -66,8 +66,9 @@ private async Task CreateEmployeeAsync(
       request.TenantID,
       request.UserID,
       companyEntity.ID,
-      None,
-      None,
+      AssignedBranchId: None,
+      AssignedDepartmentId: None,
+      ReportsToId: None,
       request.FirstName,
       request.LastName,
       request.FullName);

src/API.Core/Messages/Commands/EmployeeManagementCommand.cs

@@ -7,7 +7,8 @@ public record EmployeeManagementCommand(
   Guid TenantID,
   Guid UserID,
   Option<BranchId> AssignedBranchId,
-  Option<DepartmentId> AssignedDepartmentId)
+  Option<DepartmentId> AssignedDepartmentId,
+  Option<EmployeeId> ReportsToId)
   : EntityTenantUserCommand<EmployeeEntity, EmployeeId, Guid, Guid>(TenantID, UserID)
 {
   public override IEnumerable<EmployeeId> AffectingTenantEntitiesIdentities

src/API.Core/Messages/Commands/EmployeeManagementCommandHandler.cs

@@ -20,12 +20,16 @@ public async Task<Unit> Handle(
     CancellationToken cancellationToken)
   {
     var entity = await _employeeQueryRepository.GetAsync(request.ID, cancellationToken).ConfigureAwait(false);
+
     entity = entity with
     {
       AssignedBranchId = request.AssignedBranchId,
-      AssignedDepartmentId = request.AssignedDepartmentId
+      AssignedDepartmentId = request.AssignedDepartmentId,
+      ReportsToId = request.ReportsToId
     };
+
     await _employeeRepository.UpdateAsync(entity, cancellationToken).ConfigureAwait(false);
+
     return Unit.Value;
   }
 }

src/API.Core/Messages/Queries/EmployeePagingQuery.cs

@@ -7,6 +7,8 @@ public record EmployeePagingQuery(
     Guid TenantID,
     Guid UserID,
     string Search,
+    Option<EmployeeId> ReportsToId,
+    bool TopLevelOnly,
     Page Page)
   : EntityTenantQuery<EmployeeEntity, EmployeeId, Guid, PageResult<EmployeeEntity>>(TenantID)
     , IPagingQuery<EmployeeEntity>

src/API.Core/Messages/Queries/EmployeePagingQueryHandler.cs

@@ -1,25 +1,35 @@
 using Fossa.API.Core.Entities;
 using Fossa.API.Core.Repositories;
 using TIKSN.Data;
+using TIKSN.Mapping;
 
 namespace Fossa.API.Core.Messages.Queries;
 
 public class EmployeePagingQueryHandler : IRequestHandler<EmployeePagingQuery, PageResult<EmployeeEntity>>
 {
+  private readonly IMapper<EmployeeId, long> _employeeModelToDataIdentityMapper;
   private readonly IEmployeeQueryRepository _employeeQueryRepository;
 
-  public EmployeePagingQueryHandler(IEmployeeQueryRepository employeeQueryRepository)
+  public EmployeePagingQueryHandler(
+    IEmployeeQueryRepository employeeQueryRepository,
+    IMapper<EmployeeId, long> employeeModelToDataIdentityMapper)
   {
     _employeeQueryRepository =
       employeeQueryRepository ?? throw new ArgumentNullException(nameof(employeeQueryRepository));
+    _employeeModelToDataIdentityMapper = employeeModelToDataIdentityMapper ?? throw new ArgumentNullException(nameof(employeeModelToDataIdentityMapper));
   }
 
   public Task<PageResult<EmployeeEntity>> Handle(
     EmployeePagingQuery request,
     CancellationToken cancellationToken)
   {
     return _employeeQueryRepository.PageAsync(
-      new TenantEmployeePageQuery(request.TenantID, request.Search, request.Page),
+      new TenantEmployeePageQuery(
+        request.TenantID,
+        request.Search,
+        request.Page,
+        request.ReportsToId.Map(_employeeModelToDataIdentityMapper.Map),
+        request.TopLevelOnly),
       cancellationToken);
   }
 }

src/API.Core/Repositories/IEmployeeQueryRepository.cs

@@ -8,7 +8,12 @@ public interface IEmployeeQueryRepository
   , IDependencyQueryRepository<CompanyId>
   , IDependencyQueryRepository<BranchId>
   , IDependencyQueryRepository<DepartmentId>
+  , IDependencyQueryRepository<EmployeeId>
 {
+  Task<int> CountAllAsync(
+    CompanyId companyId,
+    CancellationToken cancellationToken);
+
   Task<Option<EmployeeEntity>> FindByUserIdAsync(
     Guid userId,
     CancellationToken cancellationToken);
@@ -20,8 +25,4 @@ Task<EmployeeEntity> GetByUserIdAsync(
   Task<PageResult<EmployeeEntity>> PageAsync(
     TenantEmployeePageQuery pageQuery,
     CancellationToken cancellationToken);
-
-  Task<int> CountAllAsync(
-    CompanyId companyId,
-    CancellationToken cancellationToken);
 }

src/API.Core/Repositories/TenantEmployeePageQuery.cs

@@ -4,15 +4,21 @@ namespace Fossa.API.Core.Repositories;
 
 public class TenantEmployeePageQuery : PageQuery
 {
-  public Guid TenantId { get; }
-  public string Search { get; }
-
   public TenantEmployeePageQuery(
     Guid tenantId,
     string search,
-    Page page) : base(page, estimateTotalItems: true)
+    Page page,
+    Option<long> reportsToId,
+    bool topLevelOnly) : base(page, estimateTotalItems: true)
   {
     TenantId = tenantId;
     Search = search;
+    ReportsToId = reportsToId;
+    TopLevelOnly = topLevelOnly;
   }
+
+  public Option<long> ReportsToId { get; }
+  public string Search { get; }
+  public Guid TenantId { get; }
+  public bool TopLevelOnly { get; }
 }

src/API.Core/Validators/EmployeeManagementCommandValidator.cs

@@ -10,13 +10,16 @@ public class EmployeeManagementCommandValidator : AbstractValidator<EmployeeMana
 {
   private readonly IBranchQueryRepository _branchQueryRepository;
   private readonly IDepartmentQueryRepository _departmentQueryRepository;
+  private readonly IEmployeeQueryRepository _employeeQueryRepository;
 
   public EmployeeManagementCommandValidator(
       IBranchQueryRepository branchQueryRepository,
-      IDepartmentQueryRepository departmentQueryRepository)
+      IDepartmentQueryRepository departmentQueryRepository,
+      IEmployeeQueryRepository employeeQueryRepository)
   {
     _branchQueryRepository = branchQueryRepository;
     _departmentQueryRepository = departmentQueryRepository;
+    _employeeQueryRepository = employeeQueryRepository ?? throw new ArgumentNullException(nameof(employeeQueryRepository));
 
     RuleFor(x => x.TenantID)
         .NotEmpty();
@@ -31,6 +34,21 @@ public EmployeeManagementCommandValidator(
     RuleFor(x => x.AssignedDepartmentId)
         .MustAsync(ValidateDepartmentAsync)
         .WithMessage("Department must exist and belong to the same tenant");
+
+    RuleFor(x => x.ReportsToId)
+      .MustAsync(ValidateReportsToIdBasicAsync)
+      .WithMessage("ReportsToId must exist and belong to the same tenant");
+
+    RuleFor(x => x.ReportsToId)
+      .Must((command, reportsToId) =>
+        reportsToId.Match(
+          Some: id => id != command.ID,
+          None: () => true))
+      .WithMessage("An employee cannot report to themselves.");
+
+    RuleFor(x => x.ReportsToId)
+      .MustAsync(ValidateReportsToIdNoCyclesAsync)
+      .WithMessage("ReportsToId must exist and belong to the same tenant");
   }
 
   private async Task<bool> ValidateBranchAsync(EmployeeManagementCommand command, Option<BranchId> assignedBranchId, CancellationToken cancellationToken)
@@ -58,4 +76,39 @@ private async Task<bool> ValidateDepartmentAsync(EmployeeManagementCommand comma
         },
         None: () => Task.FromResult(true)).ConfigureAwait(false);
   }
+
+  private async Task<bool> ValidateReportsToIdBasicAsync(EmployeeManagementCommand command, Option<EmployeeId> reportsToId, CancellationToken cancellationToken)
+  {
+    return await reportsToId.Match(
+        Some: async id =>
+        {
+          var reportsToEmployee = await _employeeQueryRepository.GetOrNoneAsync(id, cancellationToken).ConfigureAwait(false);
+          return reportsToEmployee.Match(
+                  Some: x => x.TenantID == command.TenantID,
+                  None: () => false);
+        },
+        None: () => Task.FromResult(true)).ConfigureAwait(false);
+  }
+
+  private async Task<bool> ValidateReportsToIdNoCyclesAsync(EmployeeManagementCommand command, Option<EmployeeId> reportsToId, CancellationToken cancellationToken)
+  {
+    return await reportsToId.Match(
+        Some: async id =>
+        {
+          var visited = new System.Collections.Generic.HashSet<EmployeeId> { command.ID };
+          return await VisitAsync(id, visited, cancellationToken).ConfigureAwait(false);
+        },
+        None: () => Task.FromResult(true)).ConfigureAwait(false);
+
+    async Task<bool> VisitAsync(EmployeeId reportsToId, ISet<EmployeeId> visited, CancellationToken cancellationToken)
+    {
+      if (!visited.Add(reportsToId))
+        return false;
+
+      var upperManager = await _employeeQueryRepository.GetAsync(reportsToId, cancellationToken).ConfigureAwait(false);
+      return await upperManager.ReportsToId.MatchAsync(
+          Some: upperManagerReportsToId => VisitAsync(upperManagerReportsToId, visited, cancellationToken),
+          None: () => true).ConfigureAwait(false);
+    }
+  }
 }

src/API.Persistence/Mongo/Entities/EmployeeMongoEntity.cs

@@ -21,6 +21,8 @@ public class EmployeeMongoEntity : IEntity<long>
 
   public long? AssignedDepartmentId { get; set; }
 
+  public long? ReportsToId { get; set; }
+
   public string? FirstName { get; set; }
 
   public string? LastName { get; set; }