PM-20576 Commands and Query for OrganizationReport

src/Core/Dirt/Reports/ReportFeatures/AddOrganizationReportCommand.cs

@@ -0,0 +1,64 @@
+using Bit.Core.Dirt.Entities;
+using Bit.Core.Dirt.Reports.ReportFeatures.Interfaces;
+using Bit.Core.Dirt.Reports.ReportFeatures.Requests;
+using Bit.Core.Dirt.Repositories;
+using Bit.Core.Exceptions;
+using Bit.Core.Repositories;
+
+namespace Bit.Core.Dirt.Reports.ReportFeatures;
+
+public class AddOrganizationReportCommand : IAddOrganizationReportCommand
+{
+    private readonly IOrganizationRepository _organizationRepo;
+    private readonly IOrganizationReportRepository _organizationReportRepo;
+
+    public AddOrganizationReportCommand(
+        IOrganizationRepository organizationRepository,
+        IOrganizationReportRepository organizationReportRepository)
+    {
+        _organizationRepo = organizationRepository;
+        _organizationReportRepo = organizationReportRepository;
+    }
+
+    public async Task<OrganizationReport> AddOrganizationReportAsync(AddOrganizationReportRequest request)
+    {
+        var (req, IsValid, errorMessage) = await ValidateRequestAsync(request);
+        if (!IsValid)
+        {
+            throw new BadRequestException(errorMessage);
+        }
+
+        var organizationReport = new OrganizationReport
+        {
+            OrganizationId = request.OrganizationId,
+            ReportData = request.ReportData,
+            Date = request.Date == default ? DateTime.UtcNow : request.Date,
+            CreationDate = DateTime.UtcNow,
+            RevisionDate = DateTime.UtcNow
+        };
+
+        organizationReport.SetNewId();
+
+        var data = await _organizationReportRepo.CreateAsync(organizationReport);
+        return data;
+    }
+
+    private async Task<Tuple<AddOrganizationReportRequest, bool, string>> ValidateRequestAsync(
+        AddOrganizationReportRequest request)
+    {
+        // verify that the organization exists
+        var organization = await _organizationRepo.GetByIdAsync(request.OrganizationId);
+        if (organization == null)
+        {
+            return new Tuple<AddOrganizationReportRequest, bool, string>(request, false, "Invalid Organization");
+        }
+
+        // ensure that we have a URL
+        if (string.IsNullOrWhiteSpace(request.ReportData))
+        {
+            return new Tuple<AddOrganizationReportRequest, bool, string>(request, false, "Report Data is required");
+        }
+
+        return new Tuple<AddOrganizationReportRequest, bool, string>(request, true, string.Empty);
+    }
+}

src/Core/Dirt/Reports/ReportFeatures/DropOrganizationReportCommand.cs

@@ -0,0 +1,31 @@
+using Bit.Core.Dirt.Reports.ReportFeatures.Interfaces;
+using Bit.Core.Dirt.Reports.ReportFeatures.Requests;
+using Bit.Core.Dirt.Repositories;
+using Bit.Core.Exceptions;
+
+namespace Bit.Core.Dirt.Reports.ReportFeatures;
+
+public class DropOrganizationReportCommand : IDropOrganizationReportCommand
+{
+    private IOrganizationReportRepository _OrganizationReportRepo;
+
+    public DropOrganizationReportCommand(
+        IOrganizationReportRepository OrganizationReportRepository)
+    {
+        _OrganizationReportRepo = OrganizationReportRepository;
+    }
+
+    public async Task DropOrganizationReportAsync(DropOrganizationReportRequest request)
+    {
+        var data = await _OrganizationReportRepo.GetByOrganizationIdAsync(request.OrganizationId);
+        if (data == null)
+        {
+            throw new BadRequestException("Organization does not have any records.");
+        }
+
+        data.Where(_ => request.OrganizationReportIds.Contains(_.Id)).ToList().ForEach(async _ =>
+        {
+            await _OrganizationReportRepo.DeleteAsync(_);
+        });
+    }
+}

src/Core/Dirt/Reports/ReportFeatures/GetOrganizationReportQuery.cs

@@ -0,0 +1,37 @@
+using Bit.Core.Dirt.Entities;
+using Bit.Core.Dirt.Reports.ReportFeatures.Interfaces;
+using Bit.Core.Dirt.Repositories;
+using Bit.Core.Exceptions;
+
+namespace Bit.Core.Dirt.Reports.ReportFeatures;
+
+public class GetOrganizationReportQuery : IGetOrganizationReportQuery
+{
+    private IOrganizationReportRepository _organizationReportRepo;
+
+    public GetOrganizationReportQuery(
+        IOrganizationReportRepository organizationReportRepo)
+    {
+        _organizationReportRepo = organizationReportRepo;
+    }
+
+    public async Task<IEnumerable<OrganizationReport>> GetOrganizationReportAsync(Guid organizationId)
+    {
+        if (organizationId == Guid.Empty)
+        {
+            throw new BadRequestException("OrganizationId is required.");
+        }
+
+        return await _organizationReportRepo.GetByOrganizationIdAsync(organizationId);
+    }
+
+    public async Task<OrganizationReport> GetLatestOrganizationReportAsync(Guid organizationId)
+    {
+        if (organizationId == Guid.Empty)
+        {
+            throw new BadRequestException("OrganizationId is required.");
+        }
+
+        return await _organizationReportRepo.GetLatestByOrganizationIdAsync(organizationId);
+    }
+}

src/Core/Dirt/Reports/ReportFeatures/Interfaces/IAddOrganizationReportCommand.cs

@@ -0,0 +1,10 @@
+
+using Bit.Core.Dirt.Entities;
+using Bit.Core.Dirt.Reports.ReportFeatures.Requests;
+
+namespace Bit.Core.Dirt.Reports.ReportFeatures.Interfaces;
+
+public interface IAddOrganizationReportCommand
+{
+    Task<OrganizationReport> AddOrganizationReportAsync(AddOrganizationReportRequest request);
+}

src/Core/Dirt/Reports/ReportFeatures/Interfaces/IDropOrganizationReportCommand.cs

@@ -0,0 +1,9 @@
+
+using Bit.Core.Dirt.Reports.ReportFeatures.Requests;
+
+namespace Bit.Core.Dirt.Reports.ReportFeatures.Interfaces;
+
+public interface IDropOrganizationReportCommand
+{
+    Task DropOrganizationReportAsync(DropOrganizationReportRequest request);
+}

src/Core/Dirt/Reports/ReportFeatures/Interfaces/IGetOrganizationReportQuery.cs

@@ -0,0 +1,9 @@
+using Bit.Core.Dirt.Entities;
+
+namespace Bit.Core.Dirt.Reports.ReportFeatures.Interfaces;
+
+public interface IGetOrganizationReportQuery
+{
+    Task<IEnumerable<OrganizationReport>> GetOrganizationReportAsync(Guid organizationId);
+    Task<OrganizationReport> GetLatestOrganizationReportAsync(Guid organizationId);
+}

src/Core/Dirt/Reports/ReportFeatures/ReportingServiceCollectionExtensions.cs

@@ -13,5 +13,7 @@ public static class ReportingServiceCollectionExtensions
         services.AddScoped<IAddPasswordHealthReportApplicationCommand, AddPasswordHealthReportApplicationCommand>();
         services.AddScoped<IGetPasswordHealthReportApplicationQuery, GetPasswordHealthReportApplicationQuery>();
         services.AddScoped<IDropPasswordHealthReportApplicationCommand, DropPasswordHealthReportApplicationCommand>();
+        services.AddScoped<IAddOrganizationReportCommand, AddOrganizationReportCommand>();
+        services.AddScoped<IDropOrganizationReportCommand, DropOrganizationReportCommand>();
     }
 }

src/Core/Dirt/Reports/ReportFeatures/Requests/AddOrganizationReportRequest.cs

@@ -0,0 +1,8 @@
+namespace Bit.Core.Dirt.Reports.ReportFeatures.Requests;
+
+public class AddOrganizationReportRequest
+{
+    public Guid OrganizationId { get; set; }
+    public string ReportData { get; set; }
+    public DateTime Date { get; set; }
+}

src/Core/Dirt/Reports/ReportFeatures/Requests/DropOrganizationReportRequest.cs

@@ -0,0 +1,7 @@
+namespace Bit.Core.Dirt.Reports.ReportFeatures.Requests;
+
+public class DropOrganizationReportRequest
+{
+    public Guid OrganizationId { get; set; }
+    public IEnumerable<Guid> OrganizationReportIds { get; set; }
+}

test/Core.Test/Dirt/ReportFeatures/AddOrganizationReportCommandTests.cs

@@ -0,0 +1,80 @@
+
+using AutoFixture;
+using Bit.Core.AdminConsole.Entities;
+using Bit.Core.Dirt.Entities;
+using Bit.Core.Dirt.Reports.ReportFeatures;
+using Bit.Core.Dirt.Reports.ReportFeatures.Requests;
+using Bit.Core.Dirt.Repositories;
+using Bit.Core.Exceptions;
+using Bit.Core.Repositories;
+using Bit.Test.Common.AutoFixture;
+using Bit.Test.Common.AutoFixture.Attributes;
+using NSubstitute;
+using Xunit;
+
+namespace Bit.Core.Test.Dirt.ReportFeatures;
+
+[SutProviderCustomize]
+public class AddOrganizationReportCommandTests
+{
+
+    [Theory]
+    [BitAutoData]
+    public async Task AddOrganizationReportAsync_ShouldReturnOrganizationReport(
+        SutProvider<AddOrganizationReportCommand> sutProvider)
+    {
+        // Arrange
+        var fixture = new Fixture();
+        var request = fixture.Create<AddOrganizationReportRequest>();
+        sutProvider.GetDependency<IOrganizationRepository>()
+            .GetByIdAsync(Arg.Any<Guid>())
+            .Returns(fixture.Create<Organization>());
+
+        sutProvider.GetDependency<IOrganizationReportRepository>()
+            .CreateAsync(Arg.Any<OrganizationReport>())
+            .Returns(c => c.Arg<OrganizationReport>());
+
+        // Act
+        var result = await sutProvider.Sut.AddOrganizationReportAsync(request);
+
+        // Assert
+        Assert.NotNull(result);
+    }
+
+    [Theory]
+    [BitAutoData]
+    public async Task AddOrganizationReportAsync_WithInvalidOrganizationId_ShouldThrowError(
+        SutProvider<AddOrganizationReportCommand> sutProvider)
+    {
+        // Arrange
+        var fixture = new Fixture();
+        var request = fixture.Create<AddOrganizationReportRequest>();
+        sutProvider.GetDependency<IOrganizationRepository>()
+            .GetByIdAsync(Arg.Any<Guid>())
+            .Returns(null as Organization);
+
+        // Act & Assert
+        var exception = await Assert.ThrowsAsync<BadRequestException>(async () => await sutProvider.Sut.AddOrganizationReportAsync(request));
+        Assert.Equal("Invalid Organization", exception.Message);
+    }
+
+    [Theory]
+    [BitAutoData]
+    public async Task AddOrganizationReportAsync_WithInvalidUrl_ShouldThrowError(
+        SutProvider<AddOrganizationReportCommand> sutProvider)
+    {
+        // Arrange
+        var fixture = new Fixture();
+        var request = fixture.Build<AddOrganizationReportRequest>()
+                        .Without(_ => _.ReportData)
+                        .Create();
+
+        sutProvider.GetDependency<IOrganizationRepository>()
+            .GetByIdAsync(Arg.Any<Guid>())
+            .Returns(fixture.Create<Organization>());
+
+        // Act & Assert
+        var exception = await Assert.ThrowsAsync<BadRequestException>(async () => await sutProvider.Sut.AddOrganizationReportAsync(request));
+        Assert.Equal("Report Data is required", exception.Message);
+    }
+}

test/Core.Test/Dirt/ReportFeatures/DeleteOrganizationReportCommandTests.cs

@@ -0,0 +1,104 @@
+using AutoFixture;
+using Bit.Core.Dirt.Entities;
+using Bit.Core.Dirt.Reports.ReportFeatures;
+using Bit.Core.Dirt.Reports.ReportFeatures.Requests;
+using Bit.Core.Dirt.Repositories;
+using Bit.Core.Exceptions;
+using Bit.Test.Common.AutoFixture;
+using Bit.Test.Common.AutoFixture.Attributes;
+using NSubstitute;
+using Xunit;
+
+namespace Bit.Core.Test.Dirt.ReportFeatures;
+
+[SutProviderCustomize]
+public class DeleteOrganizationReportCommandTests
+{
+    [Theory, BitAutoData]
+    public async Task DropOrganizationReportAsync_withValidRequest_Success(
+        SutProvider<DropOrganizationReportCommand> sutProvider)
+    {
+        // Arrange
+        var fixture = new Fixture();
+        var OrganizationReports = fixture.CreateMany<OrganizationReport>(2).ToList();
+        // only take one id from the list - we only want to drop one record
+        var request = fixture.Build<DropOrganizationReportRequest>()
+                        .With(x => x.OrganizationReportIds,
+                            OrganizationReports.Select(x => x.Id).Take(1).ToList())
+                        .Create();
+
+        sutProvider.GetDependency<IOrganizationReportRepository>()
+            .GetByOrganizationIdAsync(Arg.Any<Guid>())
+            .Returns(OrganizationReports);
+
+        // Act
+        await sutProvider.Sut.DropOrganizationReportAsync(request);
+
+        // Assert
+        await sutProvider.GetDependency<IOrganizationReportRepository>()
+            .Received(1)
+            .GetByOrganizationIdAsync(request.OrganizationId);
+
+        await sutProvider.GetDependency<IOrganizationReportRepository>()
+            .Received(1)
+            .DeleteAsync(Arg.Is<OrganizationReport>(_ =>
+                request.OrganizationReportIds.Contains(_.Id)));
+    }
+
+    [Theory, BitAutoData]
+    public async Task DropOrganizationReportAsync_withValidRequest_nothingToDrop(
+        SutProvider<DropOrganizationReportCommand> sutProvider)
+    {
+        // Arrange
+        var fixture = new Fixture();
+        var OrganizationReports = fixture.CreateMany<OrganizationReport>(2).ToList();
+        // we are passing invalid data
+        var request = fixture.Build<DropOrganizationReportRequest>()
+                .With(x => x.OrganizationReportIds, new List<Guid> { Guid.NewGuid() })
+                        .Create();
+
+        sutProvider.GetDependency<IOrganizationReportRepository>()
+            .GetByOrganizationIdAsync(Arg.Any<Guid>())
+            .Returns(OrganizationReports);
+
+        // Act
+        await sutProvider.Sut.DropOrganizationReportAsync(request);
+
+        // Assert
+        await sutProvider.GetDependency<IOrganizationReportRepository>()
+            .Received(1)
+            .GetByOrganizationIdAsync(request.OrganizationId);
+
+        await sutProvider.GetDependency<IOrganizationReportRepository>()
+            .Received(0)
+            .DeleteAsync(Arg.Any<OrganizationReport>());
+    }
+
+    [Theory, BitAutoData]
+    public async Task DropOrganizationReportAsync_withNodata_fails(
+        SutProvider<DropOrganizationReportCommand> sutProvider)
+    {
+        // Arrange
+        var fixture = new Fixture();
+        // we are passing invalid data
+        var request = fixture.Build<DropOrganizationReportRequest>()
+                .Create();
+
+        sutProvider.GetDependency<IOrganizationReportRepository>()
+            .GetByOrganizationIdAsync(Arg.Any<Guid>())
+            .Returns(null as List<OrganizationReport>);
+
+        // Act
+        await Assert.ThrowsAsync<BadRequestException>(() =>
+                sutProvider.Sut.DropOrganizationReportAsync(request));
+
+        // Assert
+        await sutProvider.GetDependency<IOrganizationReportRepository>()
+            .Received(1)
+            .GetByOrganizationIdAsync(request.OrganizationId);
+
+        await sutProvider.GetDependency<IOrganizationReportRepository>()
+            .Received(0)
+            .DeleteAsync(Arg.Any<OrganizationReport>());
+    }
+}

test/Core.Test/Dirt/ReportFeatures/GetOrganizationReportQueryTests.cs

@@ -0,0 +1,90 @@
+using AutoFixture;
+using Bit.Core.Dirt.Entities;
+using Bit.Core.Dirt.Reports.ReportFeatures;
+using Bit.Core.Dirt.Repositories;
+using Bit.Core.Exceptions;
+using Bit.Test.Common.AutoFixture;
+using Bit.Test.Common.AutoFixture.Attributes;
+using NSubstitute;
+using Xunit;
+
+namespace Bit.Core.Test.Dirt.ReportFeatures;
+
+[SutProviderCustomize]
+public class GetOrganizationReportQueryTests
+{
+    [Theory]
+    [BitAutoData]
+    public async Task GetOrganizationReportAsync_WithValidOrganizationId_ShouldReturnOrganizationReport(
+        SutProvider<GetOrganizationReportQuery> sutProvider)
+    {
+        // Arrange
+        var fixture = new Fixture();
+        var organizationId = fixture.Create<Guid>();
+        sutProvider.GetDependency<IOrganizationReportRepository>()
+            .GetByOrganizationIdAsync(Arg.Any<Guid>())
+            .Returns(fixture.CreateMany<OrganizationReport>(2).ToList());
+
+        // Act
+        var result = await sutProvider.Sut.GetOrganizationReportAsync(organizationId);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.True(result.Count() == 2);
+    }
+
+    [Theory]
+    [BitAutoData]
+    public async Task GetOrganizationReportAsync_WithInvalidOrganizationId_ShouldFail(
+        SutProvider<GetOrganizationReportQuery> sutProvider)
+    {
+        // Arrange
+        var fixture = new Fixture();
+        sutProvider.GetDependency<IOrganizationReportRepository>()
+            .GetByOrganizationIdAsync(Arg.Is<Guid>(x => x == Guid.Empty))
+            .Returns(new List<OrganizationReport>());
+
+        // Act & Assert
+        var exception = await Assert.ThrowsAsync<BadRequestException>(async () => await sutProvider.Sut.GetOrganizationReportAsync(Guid.Empty));
+
+        // Assert
+        Assert.Equal("OrganizationId is required.", exception.Message);
+    }
+
+    [Theory]
+    [BitAutoData]
+    public async Task GetLatestOrganizationReportAsync_WithValidOrganizationId_ShouldReturnOrganizationReport(
+        SutProvider<GetOrganizationReportQuery> sutProvider)
+    {
+        // Arrange
+        var fixture = new Fixture();
+        var organizationId = fixture.Create<Guid>();
+        sutProvider.GetDependency<IOrganizationReportRepository>()
+            .GetLatestByOrganizationIdAsync(Arg.Any<Guid>())
+            .Returns(fixture.Create<OrganizationReport>());
+
+        // Act
+        var result = await sutProvider.Sut.GetLatestOrganizationReportAsync(organizationId);
+
+        // Assert
+        Assert.NotNull(result);
+    }
+
+    [Theory]
+    [BitAutoData]
+    public async Task GetLatestOrganizationReportAsync_WithInvalidOrganizationId_ShouldFail(
+    SutProvider<GetOrganizationReportQuery> sutProvider)
+    {
+        // Arrange
+        var fixture = new Fixture();
+        sutProvider.GetDependency<IOrganizationReportRepository>()
+            .GetLatestByOrganizationIdAsync(Arg.Is<Guid>(x => x == Guid.Empty))
+            .Returns(default(OrganizationReport));
+
+        // Act & Assert
+        var exception = await Assert.ThrowsAsync<BadRequestException>(async () => await sutProvider.Sut.GetOrganizationReportAsync(Guid.Empty));
+
+        // Assert
+        Assert.Equal("OrganizationId is required.", exception.Message);
+    }
+}