Added functionality to approve TV requests (#10)

src/PlexRequests.Core.UnitTests/AgentGuidParserTests.cs → src/PlexRequests.Core.UnitTests/Helpers/AgentGuidParserTests.cs

@@ -7,7 +7,7 @@
 using TestStack.BDDfy;
 using Xunit;
 
-namespace PlexRequests.Core.UnitTests
+namespace PlexRequests.Core.UnitTests.Helpers
 {
     public class AgentGuidParserTests
     {

src/PlexRequests.Core.UnitTests/Helpers/RequestHelperTests.cs

@@ -0,0 +1,103 @@
+using System;
+using AutoFixture;
+using FluentAssertions;
+using PlexRequests.Core.Helpers;
+using PlexRequests.Repository.Enums;
+using PlexRequests.Repository.Models;
+using TestStack.BDDfy;
+using Xunit;
+
+namespace PlexRequests.Core.UnitTests.Helpers
+{
+    public class RequestHelperTests
+    {
+        private readonly RequestHelper _underTest;
+
+        private readonly Fixture _fixture;
+
+        private Request _request;
+        private Func<RequestStatuses> _commandAction;
+
+        public RequestHelperTests()
+        {
+            _fixture = new Fixture();
+
+            _underTest = new RequestHelper();
+        }
+
+        [Theory]
+        [InlineData(RequestStatuses.Approved)]
+        [InlineData(RequestStatuses.Rejected)]
+        [InlineData(RequestStatuses.Completed)]
+        [InlineData(RequestStatuses.PendingApproval)]
+        private void AggregateStatus_Sets_Status_When_All_Of_Same_Status(RequestStatuses status)
+        {
+            this.Given(x => x.GivenAllRequestEpisodesOfStatus(status))
+                .When(x => x.WhenACommandActionIsCreated())
+                .Then(x => x.ThenOverallStatusIsCorrect(status))
+                .BDDfy();
+        }
+
+        [Theory]
+        [InlineData(RequestStatuses.Approved)]
+        [InlineData(RequestStatuses.Rejected)]
+        [InlineData(RequestStatuses.PendingApproval)]
+        private void AggregateStatus_Sets_Status_To_PartialComplete_When_At_least_One_Episode_Complete(RequestStatuses allOtherEpisodeStatuses)
+        {
+            this.Given(x => x.GivenOneEpisodeOfStatus(RequestStatuses.Completed, allOtherEpisodeStatuses))
+                .When(x => x.WhenACommandActionIsCreated())
+                .Then(x => x.ThenOverallStatusIsCorrect(RequestStatuses.PartialCompletion))
+                .BDDfy();
+        }
+
+        [Theory]
+        [InlineData(RequestStatuses.Rejected)]
+        [InlineData(RequestStatuses.PendingApproval)]
+        private void AggregateStatus_Sets_Status_To_PartialApproval_When_At_least_One_Episode_Approved(RequestStatuses allOtherEpisodeStatuses)
+        {
+            this.Given(x => x.GivenOneEpisodeOfStatus(RequestStatuses.Approved, allOtherEpisodeStatuses))
+                .When(x => x.WhenACommandActionIsCreated())
+                .Then(x => x.ThenOverallStatusIsCorrect(RequestStatuses.PartialApproval))
+                .BDDfy();
+        }
+
+        private void GivenAllRequestEpisodesOfStatus(RequestStatuses status)
+        {
+            _request = _fixture.Create<Request>();
+
+            SetEpisodeStatuses(status);
+        }
+
+        private void GivenOneEpisodeOfStatus(RequestStatuses status, RequestStatuses allOtherEpisodeStatus)
+        {
+            _request = _fixture.Create<Request>();
+
+            SetEpisodeStatuses(allOtherEpisodeStatus);
+
+            _request.Seasons[0].Episodes[0].Status = status;
+        }
+
+        private void WhenACommandActionIsCreated()
+        {
+            _commandAction = () => _underTest.CalculateAggregatedStatus(_request);
+        }
+
+        private void ThenOverallStatusIsCorrect(RequestStatuses expectedStatus)
+        {
+            var actualStatus = _commandAction();
+
+            actualStatus.Should().Be(expectedStatus);
+        }
+
+        private void SetEpisodeStatuses(RequestStatuses status)
+        {
+            foreach (var season in _request.Seasons)
+            {
+                foreach (var episode in season.Episodes)
+                {
+                    episode.Status = status;
+                }
+            }
+        }
+    }
+}

src/PlexRequests.Core.UnitTests/CompletionServiceTests.cs → src/PlexRequests.Core.UnitTests/Services/CompletionServiceTests.cs

@@ -11,7 +11,7 @@
 using TestStack.BDDfy;
 using Xunit;
 
-namespace PlexRequests.Core.UnitTests
+namespace PlexRequests.Core.UnitTests.Services
 {
     public class CompletionServiceTests
     {

src/PlexRequests.Core/Helpers/IRequestHelper.cs

@@ -0,0 +1,10 @@
+using PlexRequests.Repository.Enums;
+using PlexRequests.Repository.Models;
+
+namespace PlexRequests.Core.Helpers
+{
+    public interface IRequestHelper
+    {
+        RequestStatuses CalculateAggregatedStatus(Request request);
+    }
+}

src/PlexRequests.Core/Helpers/RequestHelper.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Linq;
+using PlexRequests.Repository.Enums;
+using PlexRequests.Repository.Models;
+
+namespace PlexRequests.Core.Helpers
+{
+    public class RequestHelper : IRequestHelper
+    {
+        public RequestStatuses CalculateAggregatedStatus(Request request)
+        {
+            var possibleStatus = Enum.GetValues(typeof(RequestStatuses)).Cast<RequestStatuses>();
+            var statusCounts = possibleStatus.ToDictionary(status => status, count => 0);
+
+            foreach (var season in request.Seasons)
+            {
+                foreach (var episode in season.Episodes)
+                {
+                    statusCounts[episode.Status]++;
+                }
+            }
+
+            var totalStatusCounts = statusCounts.Sum(x => x.Value);
+            var overallStatus = RequestStatuses.PendingApproval;
+
+            foreach (var (status, count) in statusCounts.OrderBy(x => x.Key))
+            {
+                if (count == totalStatusCounts)
+                {
+                    overallStatus = status;
+                    break;
+                }
+
+                if (count == 0 || status == RequestStatuses.Rejected)
+                {
+                    continue;
+                }
+
+                overallStatus = status == RequestStatuses.Approved ? RequestStatuses.PartialApproval : RequestStatuses.PartialCompletion;
+            }
+
+            return overallStatus;
+        }
+    }
+}

src/PlexRequests.Core/Services/IRequestService.cs

@@ -17,5 +17,6 @@ public interface IRequestService
         Task Create(Request request);
         Task Update(Request request);
         Task DeleteRequest(Guid id);
+        RequestStatuses CalculateAggregatedStatus(Request request);
     }
 }

src/PlexRequests.Core/Services/RequestService.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
+using PlexRequests.Core.Helpers;
 using PlexRequests.Repository;
 using PlexRequests.Repository.Enums;
 using PlexRequests.Repository.Models;
@@ -10,12 +11,15 @@ namespace PlexRequests.Core.Services
     public class RequestService : IRequestService
     {
         private readonly IRequestRepository _requestRepository;
+        private readonly IRequestHelper _requestHelper;
 
         public RequestService(
-            IRequestRepository requestRepository
+            IRequestRepository requestRepository,
+            IRequestHelper requestHelper
             )
         {
             _requestRepository = requestRepository;
+            _requestHelper = requestHelper;
         }
 
         public async Task<Request> GetRequestById(Guid id)
@@ -68,5 +72,10 @@ public async Task DeleteRequest(Guid id)
         {
             await _requestRepository.Delete(id);
         }
+
+        public RequestStatuses CalculateAggregatedStatus(Request request)
+        {
+            return _requestHelper.CalculateAggregatedStatus(request);
+        }
     }
 }