Ejemplo n.º 1
0
        /// <summary>
        /// Returns a string correpsonding to the pattern 'X. Quartal' depending on
        /// the current date and the given quarterType enum.
        /// </summary>
        /// <param name="quarterType"></param>
        /// <returns></returns>
        public static string GetQuarterString(QuarterType quarterType)
        {
            var currentQuarter = GetQuarter(DateTime.Today);

            switch (quarterType)
            {
            case QuarterType.Previous:
                if (currentQuarter > 1)
                {
                    return(string.Format("{0}. Quartal {1}", currentQuarter - 1, DateTime.Today.Year));
                }
                else
                {
                    return(string.Format("4. Quartal {0}", DateTime.Today.Year - 1));
                }

            case QuarterType.Current:
                return(string.Format("{0}. Quartal {1}", currentQuarter, DateTime.Today.Year));

            case QuarterType.Next:
                if (currentQuarter == 4)
                {
                    return(string.Format("1. Quartal {0}", DateTime.Today.Year + 1));
                }
                else
                {
                    return(string.Format("{0}. Quartal {1}", currentQuarter + 1, DateTime.Today.Year));
                }

            default:
                return(string.Empty);
            }
        }
Ejemplo n.º 2
0
 /// <summary>
 /// Creates a DateExCondition object from the quarter.
 /// </summary>
 /// <param name="quarter">The quarter.</param>
 /// <returns>The DateExCondition object.</returns>
 public static DateExCondition FromQuarter(QuarterType quarter)
 {
     return(new DateExCondition(quarter)
     {
         expectTypeId = 2
     });
 }
        private string WorkOutErrorMessageForNotAllowingCreateReturn(ReturnsData source)
        {
            if (!WindowHelper.IsThereAnOpenWindow(source.CurrentDate))
            {
                return
                    ($"The {source.CurrentDate.AddYears(-1).Year} compliance period has closed. You can start submitting your {source.CurrentDate.Year} Q1 returns on 1st April.");
            }
            foreach (Quarter q in source.OpenQuarters)
            {
                if (source.ReturnsList.Count(p => p.Quarter == q) > 0)
                {
                    QuarterType nextQuarter = WorkOutNextQuarter(source.OpenQuarters);

                    int startYear;
                    if (nextQuarter == QuarterType.Q4)
                    {
                        startYear = source.NextWindow.WindowOpenDate.Year - 1;
                    }
                    else
                    {
                        startYear = source.NextWindow.WindowOpenDate.Year;
                    }

                    return
                        ($"Returns have been started or submitted for all open quarters. You can start submitting your {startYear} {nextQuarter} returns on {source.NextWindow.WindowOpenDate.ToReadableDateTime()}.");
                }
            }
            return(NotExpectedError);
        }
Ejemplo n.º 4
0
        private Return CreateSubmittedReturn(DatabaseWrapper db, QuarterType quarter, Organisation organisation)
        {
            var @return = ObligatedWeeeIntegrationCommon.CreateReturn(organisation, db.Model.AspNetUsers.First().Id, FacilityType.Aatf, 2019, quarter);

            @return.UpdateSubmitted(db.Model.AspNetUsers.First().Id, false);
            return(@return);
        }
Ejemplo n.º 5
0
            public EeeValidatorBuilder()
            {
                Year    = 2016;
                Quarter = QuarterType.Q1;
                Scheme  = A.Fake <Scheme>();

                DataAccess = A.Fake <IDataReturnVersionBuilderDataAccess>();
            }
Ejemplo n.º 6
0
 public async Task <bool> HasReturnQuarter(Guid organisationId, int year, QuarterType quarterType, EA.Weee.Core.AatfReturn.FacilityType facilityType)
 {
     return(await context.Returns
            .AnyAsync(r => r.Organisation.Id == organisationId &&
                      r.FacilityType.Value == (int)facilityType &&
                      r.Quarter.Year == year &&
                      (int)r.Quarter.Q == (int)quarterType));
 }
 public Task<int> GetNumberOfDataReturnSubmissionsAsync(Scheme scheme, int complianceYear, QuarterType quarter)
 {
     return weeeContext.DataReturnVersions
         .Where(d => d.SubmittedDate.HasValue)
         .Where(d => d.DataReturn.Scheme.Id == scheme.Id)
         .Where(d => d.DataReturn.Quarter.Year == complianceYear)
         .Where(d => d.DataReturn.Quarter.Q == quarter)
         .CountAsync();
 }
Ejemplo n.º 8
0
        public Quarter(int year, QuarterType q)
        {
            if (year < 1900 || year >= 3000)
            {
                throw new ArgumentOutOfRangeException("year");
            }

            Year = year;
            Q    = q;
        }
Ejemplo n.º 9
0
    /// <summary>
    /// logical AND
    /// </summary>
    public static QuarterType operator &(QuarterType a, QuarterType b)
    {
        QuarterType q = new QuarterType(false, false, false, false);

        q.Hx_left_restricted  = a.Hx_left_restricted && b.Hx_left_restricted;
        q.Hx_right_restricted = a.Hx_right_restricted && b.Hx_right_restricted;
        q.Vx_down_restricted  = a.Vx_down_restricted && b.Vx_down_restricted;
        q.Vx_up_restricted    = a.Vx_up_restricted && b.Vx_up_restricted;
        return(q);
    }
Ejemplo n.º 10
0
        private QuarterType WorkOutNextQuarter(List <Quarter> openQuarters)
        {
            QuarterType latestOpen = openQuarters.OrderByDescending(p => p.Q).First().Q;

            if ((int)latestOpen == 4)
            {
                return(QuarterType.Q1);
            }

            return((QuarterType)((int)latestOpen + 1));
        }
Ejemplo n.º 11
0
        public async Task <QuarterWindow> GetNextQuarterWindow(QuarterType q, int year)
        {
            int next = q == QuarterType.Q4 ? 1 : (int)q + 1;

            QuarterWindowTemplate quarterWindowTemplate = await dataAccess.GetByQuarter(next);

            DateTime startDate = new DateTime(year + quarterWindowTemplate.AddStartYears, quarterWindowTemplate.StartMonth, quarterWindowTemplate.StartDay);
            DateTime endDate   = new DateTime(year + quarterWindowTemplate.AddEndYears, quarterWindowTemplate.EndMonth, quarterWindowTemplate.EndDay);

            return(new QuarterWindow(startDate, endDate, (QuarterType)next));
        }
        public void Map_GivenReturnQuarter_ComplianceReturnPropertiesShouldBeSet(QuarterType quarter)
        {
            var returnsData = new ReturnsData(A.CollectionOfFake <ReturnData>(1).ToList(), new Quarter(2019, quarter), A.Fake <List <Quarter> >(), QuarterWindowTestHelper.GetDefaultQuarterWindow(), DateTime.Now);

            var result = returnsMap.Map(new ReturnToReturnsViewModelTransfer()
            {
                ReturnsData = returnsData
            });

            result.ComplianceYear.Should().Be(2019);
            result.Quarter.Should().Be(quarter);
        }
Ejemplo n.º 13
0
        public async void IndexPost_GivenOrganisationId_ReturnShouldBeCreated(QuarterType quarterType)
        {
            var model = new ReturnsViewModel()
            {
                OrganisationId = Guid.NewGuid(), ComplianceYear = 2019, Quarter = quarterType
            };

            await controller.Index(model);

            A.CallTo(() => weeeClient.SendAsync(A <string> ._, A <AddReturn> .That
                                                .Matches(c => c.OrganisationId.Equals(model.OrganisationId) &&
                                                         c.Quarter.Equals(model.Quarter) &&
                                                         c.Year.Equals(model.ComplianceYear)))).MustHaveHappened(Repeated.Exactly.Once);
        }
Ejemplo n.º 14
0
 private IEnumerable <WeeeDeliveredAmount> GetDeliveredAmounts(
     IEnumerable <DataReturn> dataReturns,
     Domain.Obligation.ObligationType obligationType,
     WeeeCategory category,
     QuarterType quarter)
 {
     return(dataReturns
            .Where(dr => dr.Quarter.Q == quarter)
            .Where(dr => dr.CurrentVersion != null)
            .Where(dr => dr.CurrentVersion.WeeeDeliveredReturnVersion != null)
            .SelectMany(dr => dr.CurrentVersion.WeeeDeliveredReturnVersion.WeeeDeliveredAmounts)
            .Where(wca => wca.ObligationType == obligationType)
            .Where(wca => wca.WeeeCategory == category));
 }
Ejemplo n.º 15
0
        /// <summary>
        /// Deletes a given QuarterType object.
        /// </summary>
        /// <param name="QuarterType"></param>

        public void QuarterTypeRemove(QuarterType quartertype)
        {
            try
            {
                using (NetballEntities context = new NetballEntities())
                {
                    context.Entry(quartertype).State = EntityState.Deleted;
                    context.SaveChanges();
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Ejemplo n.º 16
0
        public async Task <Guid> HandleAsync(ProcessDataReturnXmlFile message)
        {
            Scheme scheme = await dataAccess.FetchSchemeByOrganisationIdAsync(message.OrganisationId);

            authorization.EnsureSchemeAccess(scheme.Id);

            // record XML processing start time
            Stopwatch stopwatch = Stopwatch.StartNew();

            var xmlGeneratorResult = xmlGenerator.GenerateDataReturns <SchemeReturn>(message);
            DataReturnUpload dataReturnUpload;

            if (xmlGeneratorResult.SchemaErrors.Any())
            {
                dataReturnUpload = new DataReturnUpload(scheme, xmlGeneratorResult.XmlString,
                                                        xmlGeneratorResult.SchemaErrors.Select(e => e.ToDataReturnsUploadError()).ToList(),
                                                        message.FileName, null, null);
            }
            else
            {
                int         complianceYear = int.Parse(xmlGeneratorResult.DeserialisedType.ComplianceYear);
                QuarterType quarter        = xmlGeneratorResult.DeserialisedType.ReturnPeriod.ToDomainQuarterType();

                var pcsReturnVersionBuilder         = dataReturnVersionBuilderDelegate(scheme, new Quarter(complianceYear, quarter));
                var dataReturnVersionFromXmlBuilder = dataReturnVersionFromXmlBuilderDelegate(pcsReturnVersionBuilder);

                var dataReturnVersionBuilderResult = await dataReturnVersionFromXmlBuilder.Build(xmlGeneratorResult.DeserialisedType);

                var allErrors = (dataReturnVersionBuilderResult.ErrorData
                                 .Select(e => new DataReturnUploadError(e.ErrorLevel.ToDomainErrorLevel(), Domain.Error.UploadErrorType.Business, e.Description)))
                                .ToList();

                dataReturnUpload = new DataReturnUpload(scheme, xmlGeneratorResult.XmlString, allErrors, message.FileName, complianceYear, Convert.ToInt32(quarter));

                if (!dataReturnVersionBuilderResult.ErrorData.Any(e => e.ErrorLevel == ErrorLevel.Error))
                {
                    dataReturnUpload.SetDataReturnVersion(dataReturnVersionBuilderResult.DataReturnVersion);
                }
            }

            // Record XML processing end time
            stopwatch.Stop();
            dataReturnUpload.SetProcessTime(stopwatch.Elapsed);

            await dataAccess.AddAndSaveAsync(dataReturnUpload);

            return(dataReturnUpload.Id);
        }
 public DataReturnForSubmission(
     Guid dataReturnUploadId,
     Guid organisationId,
     int? year,
     QuarterType? quarter,
     IReadOnlyCollection<DataReturnWarning> warnings,
     IReadOnlyCollection<DataReturnError> errors,
     bool isResubmission)
 {
     DataReturnUploadId = dataReturnUploadId;
     OrganisationId = organisationId;
     Quarter = quarter;
     Year = year;
     Warnings = warnings;
     Errors = errors;
     IsResubmission = isResubmission;
 }
Ejemplo n.º 18
0
        public async Task GivenSomeCollectedWeeeExists_StoredProcedureReturnsThatDataSuccessfully()
        {
            const int complianceYear = 1372;
            const Domain.Obligation.ObligationType obligationType = Domain.Obligation.ObligationType.B2B;
            const int          collectedTonnage = 179;
            const WeeeCategory category         = WeeeCategory.AutomaticDispensers;
            const QuarterType  quarterType      = QuarterType.Q1;

            using (var dbWrapper = new DatabaseWrapper())
            {
                var modelHelper = new ModelHelper(dbWrapper.Model);

                var org = modelHelper.CreateOrganisation();

                var scheme = modelHelper.CreateScheme(org);
                scheme.ObligationType = (int)obligationType;

                var weeeCollectedReturnVersion = modelHelper.CreateWeeeCollectedReturnVersion();

                modelHelper.CreateDataReturnVersion(scheme, complianceYear, (int)quarterType, true, null, weeeCollectedReturnVersion);

                await dbWrapper.Model.SaveChangesAsync();

                var weeeCollectedAmount = modelHelper.CreateWeeeCollectedAmount(obligationType, collectedTonnage, category);

                modelHelper.CreateWeeeCollectedReturnVersionAmount(weeeCollectedAmount, weeeCollectedReturnVersion);

                await dbWrapper.Model.SaveChangesAsync();

                var results =
                    await dbWrapper.StoredProcedures.SpgSchemeWeeeCsvAsync(complianceYear, null, obligationType.ToString());

                Assert.NotEmpty(results.CollectedAmounts);

                var collectedAmountResult = results.CollectedAmounts.Single(ca => ca.SchemeId == scheme.Id);

                Assert.NotNull(collectedAmountResult);
                Assert.Equal((int)quarterType, collectedAmountResult.QuarterType);
                Assert.Equal(collectedTonnage, collectedAmountResult.Tonnage);
                Assert.Equal((int)category, collectedAmountResult.WeeeCategory);

                var schemeResult = results.Schemes.Single(s => s.SchemeId == scheme.Id);

                Assert.NotNull(schemeResult);
            }
        }
        public void CreateResults_WithSingleQuarter_PopulatesQuarterWithSum(QuarterType quarterType)
        {
            // Arrange
            var year     = 1900 + fixture.Create <int>();
            var category = fixture.Create <WeeeCategory>();

            var received = fixture.Build <WeeeObligatedData>()
                           .With(r => r.CategoryId, (int)category)
                           .CreateMany().ToList();
            var reused = fixture.Build <WeeeObligatedData>()
                         .With(r => r.CategoryId, (int)category)
                         .CreateMany().ToList();
            var sentOn = fixture.Build <WeeeObligatedData>()
                         .With(r => r.CategoryId, (int)category)
                         .CreateMany().ToList();
            var partialReturn = fixture.Build <PartialAatfReturn>()
                                .With(r => r.Quarter, new Quarter(year, quarterType))
                                .With(r => r.ObligatedWeeeReceivedData, received)
                                .With(r => r.ObligatedWeeeReusedData, reused)
                                .With(r => r.ObligatedWeeeSentOnData, sentOn)
                                .Create();

            var handler = new GetUkWeeeAtAatfsCsvHandler(
                A.Dummy <IWeeeAuthorization>(),
                A.Dummy <IGetUkWeeeAtAatfsCsvDataAccess>(),
                A.Dummy <CsvWriterFactory>());

            // Act
            var results = handler.CreateResults(new List <PartialAatfReturn>()
            {
                partialReturn
            }, year.ToString());

            // Assert
            var result = results.SingleOrDefault(r => r.Category == category && r.TimePeriod == quarterType.ToString());

            Assert.NotNull(result);
            Assert.Equal(received.Sum(r => r.B2B), result.B2bForTreatment);
            Assert.Equal(received.Sum(r => r.B2C), result.B2cForTreatment);
            Assert.Equal(reused.Sum(r => r.B2B), result.B2bForReuse);
            Assert.Equal(reused.Sum(r => r.B2C), result.B2cForReuse);
            Assert.Equal(sentOn.Sum(r => r.B2B), result.B2bForAatf);
            Assert.Equal(sentOn.Sum(r => r.B2C), result.B2cForAatf);
        }
Ejemplo n.º 20
0
        public int?QuarterTypeUpdateTransaction(QuarterType quartertype)
        {
            int?quartertypeID = null;

            try
            {
                using (NetballEntities context = new NetballEntities())
                {
                    context.Entry(quartertype).State = EntityState.Modified;
                    context.SaveChanges();
                    quartertypeID = quartertype.QuarterTypeID;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return(quartertypeID);
        }
Ejemplo n.º 21
0
        public QuarterType GetQuarterType(int quartertypeID)
        {
            QuarterType quartertype = new QuarterType();

            try
            {
                using (NetballEntities context = new NetballEntities())
                {
                    context.Configuration.ProxyCreationEnabled = false;
                    quartertype = context.QuarterTypes
                                  .Include(c => c.GameQuarters)
                                  .Where(c => c.QuarterTypeID == quartertypeID)
                                  .FirstOrDefault();
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return(quartertype);
        }
        private Return CreateReturn(Guid id, int year, QuarterType quarter, Organisation organisation = null, DateTime?submittedDate = null, DomainFacilityType facilityType = null)
        {
            var @return = A.Fake <Return>();

            A.CallTo(() => @return.Id).Returns(id);
            A.CallTo(() => @return.Quarter).Returns(new Quarter(year, quarter));
            A.CallTo(() => @return.SubmittedDate).Returns(submittedDate ?? fixture.Create <DateTime>());

            if (organisation == null)
            {
                organisation = A.Fake <Organisation>();
                A.CallTo(() => organisation.Id).Returns(fixture.Create <Guid>());
            }

            A.CallTo(() => @return.Organisation).Returns(organisation);

            if (facilityType == null)
            {
                facilityType = DomainFacilityType.Aatf;
            }
            A.CallTo(() => @return.FacilityType).Returns(facilityType);

            return(@return);
        }
Ejemplo n.º 23
0
        public QuarterWindow(DateTime windowOpenDate, DateTime windowClosedDate, QuarterType quarterType)
        {
            int startMonth;
            int startYear;

            if (quarterType == QuarterType.Q4)
            {
                startMonth = 10;
                startYear  = windowOpenDate.Year - 1;
            }
            else
            {
                startMonth = windowOpenDate.Month - 3;
                startYear  = windowOpenDate.Year;
            }

            QuarterStart = new DateTime(startYear, startMonth, 1);
            QuarterEnd   = windowOpenDate.AddDays(-1);

            WindowOpenDate   = windowOpenDate;
            WindowClosedDate = windowClosedDate;

            QuarterType = quarterType;
        }
Ejemplo n.º 24
0
 /// <summary>
 /// Quarters house a yearNum, quarterType, and as well as a list of classes
 /// </summary>
 /// <param name="yN"></param>
 /// <param name="qT"></param>
 /// 
 public Quarter(int yN, QuarterType qT)
 {
     classes = new ObservableCollection<Class>();
     yearNum = yN;
     quarterType = qT;
 }
Ejemplo n.º 25
0
        public async Task HandleAsync_GivenAddReturnRequest_DataAccessSubmitsIsCalled(QuarterType quarterType, FacilityType facility)
        {
            var request = new AddReturn {
                OrganisationId = Guid.NewGuid(), Quarter = quarterType, Year = year, FacilityType = Core.AatfReturn.FacilityType.Aatf
            };

            var @return      = A.Dummy <Return>();
            var organisation = new Organisation();
            var userId       = Guid.NewGuid();

            A.CallTo(() => userContext.UserId).Returns(userId);
            A.CallTo(() => genericDataAccess.GetById <Organisation>(request.OrganisationId)).Returns(organisation);
            A.CallTo(() => returnFactory.GetReturnQuarter(A <Guid> ._, A <FacilityType> ._)).Returns(new Quarter(year, quarterType));

            await handler.HandleAsync(request);

            A.CallTo(() => returnDataAccess.Submit(A <Return> .That.Matches(c => c.Quarter.Year == request.Year && (int)c.Quarter.Q == (int)quarterType && c.Organisation.Equals(organisation) && c.CreatedById.Equals(userId.ToString())))).MustHaveHappened(Repeated.Exactly.Once);
        }
Ejemplo n.º 26
0
 public QuarterWindow(DateTime startDate, DateTime endDate, QuarterType quarterType)
 {
     StartDate   = startDate;
     EndDate     = endDate;
     QuarterType = quarterType;
 }
 public Task <int> GetNumberOfDataReturnSubmissionsAsync(Scheme scheme, int complianceYear, QuarterType quarter)
 {
     return(weeeContext.DataReturnVersions
            .Where(d => d.SubmittedDate.HasValue)
            .Where(d => d.DataReturn.Scheme.Id == scheme.Id)
            .Where(d => d.DataReturn.Quarter.Year == complianceYear)
            .Where(d => d.DataReturn.Quarter.Q == quarter)
            .CountAsync());
 }
Ejemplo n.º 28
0
        public void IsOpen_DayAfterReportingWindowCloses_ReturnsFalse(DateTime windowOpenDate, QuarterType quarterType)
        {
            var quarter = new QuarterWindow(windowOpenDate, windowClosedDate, quarterType);

            var date = new DateTime(2019, 03, 17);

            var result = quarter.IsOpen(date);

            result.Should().BeFalse();
        }
Ejemplo n.º 29
0
        public void Constructor_GivenConstructorParameters_PropertiesShouldBeSet(DateTime windowOpenDate, QuarterType quarterType)
        {
            var quarter = new QuarterWindow(windowOpenDate, windowClosedDate, quarterType);

            quarter.QuarterType.Should().Be(quarterType);
            quarter.WindowOpenDate.Should().Be(windowOpenDate);
            quarter.WindowClosedDate.Should().Be(windowClosedDate);
        }
Ejemplo n.º 30
0
        public void IsOpen_DayBeforeReportingWindowOpens_ReturnsFalse(DateTime windowOpenDate, int currentDay, int currentMonth, QuarterType quarterType)
        {
            var quarter = new QuarterWindow(windowOpenDate, windowClosedDate, quarterType);
            var date    = new DateTime(2018, currentMonth, currentDay);

            var result = quarter.IsOpen(date);

            result.Should().BeFalse();
        }
Ejemplo n.º 31
0
        public void IsOpen_DayReportingWindowOpens_ReturnsTrue(DateTime windowOpenDate, int currentMonth, int currentYear, QuarterType quarterType)
        {
            var quarter = new QuarterWindow(windowOpenDate, windowClosedDate, quarterType);

            var date = new DateTime(currentYear, currentMonth, 01);

            var result = quarter.IsOpen(date);

            result.Should().BeTrue();
        }
        public static Return CreateReturn(Organisation organisation, string createdById, FacilityType facilityType, int year, QuarterType quarter)
        {
            if (organisation == null)
            {
                organisation = Organisation.CreateSoleTrader("Test Organisation");
            }

            return(new Return(organisation, new Quarter(year, quarter), createdById, facilityType));
        }
Ejemplo n.º 33
0
 // return null if no quarter of this type exists
 public Quarter getQuarter(QuarterType qT)
 {
     foreach (Quarter q in quarters)
     {
         if (q.QuarterType.Equals(qT))
             return q;
     }
     return null;
 }
            public EeeValidatorBuilder()
            {
                Year = 2016;
                Quarter = QuarterType.Q1;
                Scheme = A.Fake<Scheme>();

                DataAccess = A.Fake<IDataReturnVersionBuilderDataAccess>();
            }
        public async Task FetchPartialAatfReturnsForComplianceYearAsync_DoesNotIncludePreviousVersions(QuarterType quarter)
        {
            // Arrange
            var year           = 1900 + fixture.Create <int>();
            var previousId     = fixture.Create <Guid>();
            var id             = fixture.Create <Guid>();
            var organisationId = fixture.Create <Guid>();
            var organisation   = A.Fake <Organisation>();

            A.CallTo(() => organisation.Id).Returns(organisationId);

            var returns = new List <Return>
            {
                CreateReturn(previousId, year, quarter, organisation, new DateTime(year, 01, 01)),
                CreateReturn(id, year, quarter, organisation, new DateTime(year, 01, 02))
            };
            var returnsDbSet = helper.GetAsyncEnabledDbSet(returns);

            A.CallTo(() => context.Returns).Returns(returnsDbSet);

            var received = new List <WeeeReceived>
            {
                CreateWeeeReceived(previousId, out var categoryReceivedPrevious, out var receivedB2bQ1Previous, out var receivedB2cQ1Previous),
                CreateWeeeReceived(id, out var categoryReceived, out var receivedB2bQ1, out var receivedB2cQ1)
            };
            var receivedDbSet = helper.GetAsyncEnabledDbSet(received);

            A.CallTo(() => context.WeeeReceived).Returns(receivedDbSet);

            var reused = new List <WeeeReused>
            {
                CreateWeeeReused(previousId, out var categoryReusedPrevious, out var reusedB2bQ1Previous, out var reusedB2cQ1Previous),
                CreateWeeeReused(id, out var categoryReused, out var reusedB2bQ1, out var reusedB2cQ1)
            };
            var reusedDbSet = helper.GetAsyncEnabledDbSet(reused);

            A.CallTo(() => context.WeeeReused).Returns(reusedDbSet);

            var sentOn = new List <WeeeSentOn>
            {
                CreateWeeeSentOn(previousId, out var categorySentOnPrevious, out var sentOnB2bQ1Previous, out var sentOnB2cQ1Previous),
                CreateWeeeSentOn(id, out var categorySentOn, out var sentOnB2bQ1, out var sentOnB2cQ1)
            };
            var sentOnDbSet = helper.GetAsyncEnabledDbSet(sentOn);

            A.CallTo(() => context.WeeeSentOn).Returns(sentOnDbSet);

            // Act
            var results = await dataAccess.FetchPartialAatfReturnsForComplianceYearAsync(year);

            // Assert
            Assert.Equal(1, results.Count());

            var result = results.First();

            Assert.Equal(year, result.Quarter.Year);
            Assert.Equal(1, result.ObligatedWeeeReceivedData.Count());
            AssertWeeeObligatedData(result.ObligatedWeeeReceivedData.First(), categoryReceived, receivedB2bQ1, receivedB2cQ1);
            Assert.Equal(1, result.ObligatedWeeeReusedData.Count());
            AssertWeeeObligatedData(result.ObligatedWeeeReusedData.First(), categoryReused, reusedB2bQ1, reusedB2cQ1);
            Assert.Equal(1, result.ObligatedWeeeSentOnData.Count());
            AssertWeeeObligatedData(result.ObligatedWeeeSentOnData.First(), categorySentOn, sentOnB2bQ1, sentOnB2cQ1);
        }