public void CreateResults_WithNoDeliveredAmounts_PopulatesTotalAsNull()
        {
            // Arrange
            SpgSchemeWeeeCsvResult data = new SpgSchemeWeeeCsvResult();

            data.Schemes.Add(new SpgSchemeWeeeCsvResult.SchemeResult
            {
                SchemeId = Guid.NewGuid()
            });

            GetSchemeWeeeCsvHandler handler = new GetSchemeWeeeCsvHandler(
                A.Dummy <IStoredProcedures>(),
                A.Dummy <IWeeeAuthorization>(),
                A.Dummy <CsvWriterFactory>());

            // Act
            IEnumerable <GetSchemeWeeeCsvHandler.CsvResult> results = handler.CreateResults(
                data,
                new List <string>()
            {
                "AATF1"
            },
                new List <string>()
            {
                "AE1"
            });

            // Assert
            GetSchemeWeeeCsvHandler.CsvResult result1 = results.First();
            Assert.Equal(null, result1.TotalDelivered);
        }
        public async Task HandleAsync_WithSchemeSpecified_GeneratesCorrectFileName()
        {
            IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();

            IStoredProcedures storedProcedures = A.Fake <IStoredProcedures>();

            SpgSchemeWeeeCsvResult storedProcedureResult = new SpgSchemeWeeeCsvResult();

            storedProcedureResult.Schemes.Add(new SpgSchemeWeeeCsvResult.SchemeResult()
            {
                SchemeId       = new Guid("C5AD2FF9-941D-4D6F-B68B-9805DD7E1FD1"),
                ApprovalNumber = "WEE/AA1111AA/SCH"
            });

            A.CallTo(() => storedProcedures.SpgSchemeWeeeCsvAsync(A <int> ._, A <Guid?> ._, A <string> ._))
            .Returns(storedProcedureResult);

            GetSchemeWeeeCsvHandler handler = new GetSchemeWeeeCsvHandler(
                storedProcedures,
                authorization,
                A.Dummy <CsvWriterFactory>());

            GetSchemeWeeeCsv request = new GetSchemeWeeeCsv(2016, new Guid("C5AD2FF9-941D-4D6F-B68B-9805DD7E1FD1"), ObligationType.B2C);

            // Act
            SystemTime.Freeze(new DateTime(2016, 12, 31, 23, 59, 0));
            FileInfo result = await handler.HandleAsync(request);

            SystemTime.Unfreeze();

            // Assert
            Assert.Equal("2016_WEEAA1111AASCH_B2C_schemeWEEE_31122016_2359.csv", result.FileName);
        }
        public void CreateResults_WithCollectedAmountWithSourceType2_PopulatesFinalHoldersWithValue()
        {
            // Arrange
            SpgSchemeWeeeCsvResult data = new SpgSchemeWeeeCsvResult();

            data.Schemes.Add(new SpgSchemeWeeeCsvResult.SchemeResult()
            {
                SchemeId = new Guid("3E299215-BA37-403F-B398-EB345371F3D2")
            });

            data.CollectedAmounts.Add(new SpgSchemeWeeeCsvResult.CollectedAmountResult()
            {
                SchemeId     = new Guid("3E299215-BA37-403F-B398-EB345371F3D2"),
                QuarterType  = 1,
                WeeeCategory = 1,
                SourceType   = 2,
                Tonnage      = 123.456m
            });

            GetSchemeWeeeCsvHandler handler = new GetSchemeWeeeCsvHandler(
                A.Dummy <IStoredProcedures>(),
                A.Dummy <IWeeeAuthorization>(),
                A.Dummy <CsvWriterFactory>());

            // Act
            IEnumerable <GetSchemeWeeeCsvHandler.CsvResult> results = handler.CreateResults(
                data,
                A.Dummy <IEnumerable <string> >(),
                A.Dummy <IEnumerable <string> >());

            // Assert
            GetSchemeWeeeCsvHandler.CsvResult result1 = results.First();
            Assert.Equal(123.456m, result1.FinalHolders);
        }
        public void CreateResults_WithNoCollectedAmounts_PopulatesFinalHoldersAsNull()
        {
            // Arrange
            SpgSchemeWeeeCsvResult data = new SpgSchemeWeeeCsvResult();

            data.Schemes.Add(new SpgSchemeWeeeCsvResult.SchemeResult
            {
                SchemeId = Guid.NewGuid()
            });

            GetSchemeWeeeCsvHandler handler = new GetSchemeWeeeCsvHandler(
                A.Dummy <IStoredProcedures>(),
                A.Dummy <IWeeeAuthorization>(),
                A.Dummy <CsvWriterFactory>());

            // Act
            IEnumerable <GetSchemeWeeeCsvHandler.CsvResult> results = handler.CreateResults(
                data,
                A.Dummy <IEnumerable <string> >(),
                A.Dummy <IEnumerable <string> >());

            // Assert
            GetSchemeWeeeCsvHandler.CsvResult result1 = results.First();
            Assert.Equal(null, result1.FinalHolders);
        }
        public void CreateResults_WithDeliveredAmountForLocationType1_PopulatesAeAmountAndTotal()
        {
            // Arrange
            SpgSchemeWeeeCsvResult data = new SpgSchemeWeeeCsvResult();

            data.Schemes.Add(new SpgSchemeWeeeCsvResult.SchemeResult()
            {
                SchemeId = new Guid("3E299215-BA37-403F-B398-EB345371F3D2")
            });

            data.DeliveredAmounts.Add(new SpgSchemeWeeeCsvResult.DeliveredAmountResult()
            {
                SchemeId               = new Guid("3E299215-BA37-403F-B398-EB345371F3D2"),
                QuarterType            = 1,
                WeeeCategory           = 1,
                LocationType           = 1,
                LocationApprovalNumber = "AE1",
                Tonnage = 123.456m
            });

            GetSchemeWeeeCsvHandler handler = new GetSchemeWeeeCsvHandler(
                A.Dummy <IStoredProcedures>(),
                A.Dummy <IWeeeAuthorization>(),
                A.Dummy <CsvWriterFactory>());

            // Act
            IEnumerable <GetSchemeWeeeCsvHandler.CsvResult> results = handler.CreateResults(
                data,
                new List <string>()
            {
                "AATF1"
            },
                new List <string>()
            {
                "AE1"
            });

            // Assert
            GetSchemeWeeeCsvHandler.CsvResult result1 = results.First();
            Assert.Equal(123.456m, result1.AeTonnage["AE1"]);
            Assert.Equal(123.456m, result1.TotalDelivered);
        }
        public void CreateResults_WithOneScheme_CreatesAResultForEachCategoryAndEachQuarter()
        {
            // Arrange
            SpgSchemeWeeeCsvResult data = new SpgSchemeWeeeCsvResult();

            data.Schemes.Add(new SpgSchemeWeeeCsvResult.SchemeResult
            {
                SchemeId = Guid.NewGuid()
            });

            GetSchemeWeeeCsvHandler handler = new GetSchemeWeeeCsvHandler(
                A.Dummy <IStoredProcedures>(),
                A.Dummy <IWeeeAuthorization>(),
                A.Dummy <CsvWriterFactory>());

            // Act
            IEnumerable <GetSchemeWeeeCsvHandler.CsvResult> results = handler.CreateResults(
                data,
                A.Dummy <IEnumerable <string> >(),
                A.Dummy <IEnumerable <string> >());

            // Assert
            Assert.Equal(56, results.Count());
            Assert.Collection(results.Take(15), // Just examine the first 15 rows
                              r => { Assert.Equal(1, r.Category); Assert.Equal(1, r.QuarterType); },
                              r => { Assert.Equal(2, r.Category); Assert.Equal(1, r.QuarterType); },
                              r => { Assert.Equal(3, r.Category); Assert.Equal(1, r.QuarterType); },
                              r => { Assert.Equal(4, r.Category); Assert.Equal(1, r.QuarterType); },
                              r => { Assert.Equal(5, r.Category); Assert.Equal(1, r.QuarterType); },
                              r => { Assert.Equal(6, r.Category); Assert.Equal(1, r.QuarterType); },
                              r => { Assert.Equal(7, r.Category); Assert.Equal(1, r.QuarterType); },
                              r => { Assert.Equal(8, r.Category); Assert.Equal(1, r.QuarterType); },
                              r => { Assert.Equal(9, r.Category); Assert.Equal(1, r.QuarterType); },
                              r => { Assert.Equal(10, r.Category); Assert.Equal(1, r.QuarterType); },
                              r => { Assert.Equal(11, r.Category); Assert.Equal(1, r.QuarterType); },
                              r => { Assert.Equal(12, r.Category); Assert.Equal(1, r.QuarterType); },
                              r => { Assert.Equal(13, r.Category); Assert.Equal(1, r.QuarterType); },
                              r => { Assert.Equal(14, r.Category); Assert.Equal(1, r.QuarterType); },
                              r => { Assert.Equal(1, r.Category); Assert.Equal(2, r.QuarterType); });
            // etc...
        }
        public void CreateResults_WithMultipleSchemes_OrdersSchemesBySchemeName()
        {
            // Arrange
            SpgSchemeWeeeCsvResult data = new SpgSchemeWeeeCsvResult();

            data.Schemes.Add(new SpgSchemeWeeeCsvResult.SchemeResult()
            {
                SchemeName = "Scheme B",
                SchemeId   = Guid.NewGuid()
            });

            data.Schemes.Add(new SpgSchemeWeeeCsvResult.SchemeResult()
            {
                SchemeName = "Scheme A",
                SchemeId   = Guid.NewGuid()
            });

            data.Schemes.Add(new SpgSchemeWeeeCsvResult.SchemeResult()
            {
                SchemeName = "Scheme C",
                SchemeId   = Guid.NewGuid()
            });

            GetSchemeWeeeCsvHandler handler = new GetSchemeWeeeCsvHandler(
                A.Dummy <IStoredProcedures>(),
                A.Dummy <IWeeeAuthorization>(),
                A.Dummy <CsvWriterFactory>());

            // Act
            IEnumerable <GetSchemeWeeeCsvHandler.CsvResult> results = handler.CreateResults(
                data,
                A.Dummy <IEnumerable <string> >(),
                A.Dummy <IEnumerable <string> >());

            // Assert
            GetSchemeWeeeCsvHandler.CsvResult result1 = results.First();
            Assert.Equal("Scheme A", result1.SchemeName);
        }
        public void CreateResults_WithMultipleSchemes_OrdersSchemesBySchemeName()
        {
            // Arrange
            SpgSchemeWeeeCsvResult data = new SpgSchemeWeeeCsvResult();

            data.Schemes.Add(new SpgSchemeWeeeCsvResult.SchemeResult()
            {
                SchemeName = "Scheme B",
                SchemeId = Guid.NewGuid()
            });

            data.Schemes.Add(new SpgSchemeWeeeCsvResult.SchemeResult()
            {
                SchemeName = "Scheme A",
                SchemeId = Guid.NewGuid()
            });

            data.Schemes.Add(new SpgSchemeWeeeCsvResult.SchemeResult()
            {
                SchemeName = "Scheme C",
                SchemeId = Guid.NewGuid()
            });

            GetSchemeWeeeCsvHandler handler = new GetSchemeWeeeCsvHandler(
                A.Dummy<IStoredProcedures>(),
                A.Dummy<IWeeeAuthorization>(),
                A.Dummy<CsvWriterFactory>());

            // Act
            IEnumerable<GetSchemeWeeeCsvHandler.CsvResult> results = handler.CreateResults(
                data,
                A.Dummy<IEnumerable<string>>(),
                A.Dummy<IEnumerable<string>>());

            // Assert
            GetSchemeWeeeCsvHandler.CsvResult result1 = results.First();
            Assert.Equal("Scheme A", result1.SchemeName);
        }
        public void CreateResults_WithDeliveredAmountsForVariousSchemesCategoriesAndQuarters_SumsAmountsAndPopulatesTotals()
        {
            // Arrange
            SpgSchemeWeeeCsvResult data = new SpgSchemeWeeeCsvResult();

            data.Schemes.Add(new SpgSchemeWeeeCsvResult.SchemeResult()
            {
                SchemeId = new Guid("3E299215-BA37-403F-B398-EB345371F3D2"),
                SchemeName = "Scheme 1"
            });

            data.Schemes.Add(new SpgSchemeWeeeCsvResult.SchemeResult()
            {
                SchemeId = new Guid("9E1EE29C-5FFD-4137-BA55-98C0F0F7212D"),
                SchemeName = "Scheme 2"
            });

            data.DeliveredAmounts.Add(new SpgSchemeWeeeCsvResult.DeliveredAmountResult()
            {
                SchemeId = new Guid("3E299215-BA37-403F-B398-EB345371F3D2"),
                QuarterType = 1,
                WeeeCategory = 1,
                LocationType = 0,
                LocationApprovalNumber = "AATF1",
                Tonnage = 1
            });

            data.DeliveredAmounts.Add(new SpgSchemeWeeeCsvResult.DeliveredAmountResult()
            {
                SchemeId = new Guid("3E299215-BA37-403F-B398-EB345371F3D2"),
                QuarterType = 1,
                WeeeCategory = 1,
                LocationType = 1,
                LocationApprovalNumber = "AE1",
                Tonnage = 2
            });

            data.DeliveredAmounts.Add(new SpgSchemeWeeeCsvResult.DeliveredAmountResult()
            {
                SchemeId = new Guid("3E299215-BA37-403F-B398-EB345371F3D2"),
                QuarterType = 4,
                WeeeCategory = 1,
                LocationType = 1,
                LocationApprovalNumber = "AE1",
                Tonnage = 9999
            });

            data.DeliveredAmounts.Add(new SpgSchemeWeeeCsvResult.DeliveredAmountResult()
            {
                SchemeId = new Guid("3E299215-BA37-403F-B398-EB345371F3D2"),
                QuarterType = 1,
                WeeeCategory = 14,
                LocationType = 1,
                LocationApprovalNumber = "AE1",
                Tonnage = 9999
            });

            data.DeliveredAmounts.Add(new SpgSchemeWeeeCsvResult.DeliveredAmountResult()
            {
                SchemeId = new Guid("9E1EE29C-5FFD-4137-BA55-98C0F0F7212D"),
                QuarterType = 1,
                WeeeCategory = 1,
                LocationType = 1,
                LocationApprovalNumber = "AE1",
                Tonnage = 9999
            });

            GetSchemeWeeeCsvHandler handler = new GetSchemeWeeeCsvHandler(
                A.Dummy<IStoredProcedures>(),
                A.Dummy<IWeeeAuthorization>(),
                A.Dummy<CsvWriterFactory>());

            // Act
            IEnumerable<GetSchemeWeeeCsvHandler.CsvResult> results = handler.CreateResults(
                data,
                new List<string>() { "AATF1" },
                new List<string>() { "AE1" });

            // Assert
            GetSchemeWeeeCsvHandler.CsvResult result1 = results.First();
            Assert.Equal(3, result1.TotalDelivered);
        }
        public void CreateResults_WithDeliveredAmountForLocationType1_PopulatesAeAmountAndTotal()
        {
            // Arrange
            SpgSchemeWeeeCsvResult data = new SpgSchemeWeeeCsvResult();

            data.Schemes.Add(new SpgSchemeWeeeCsvResult.SchemeResult()
            {
                SchemeId = new Guid("3E299215-BA37-403F-B398-EB345371F3D2")
            });

            data.DeliveredAmounts.Add(new SpgSchemeWeeeCsvResult.DeliveredAmountResult()
            {
                SchemeId = new Guid("3E299215-BA37-403F-B398-EB345371F3D2"),
                QuarterType = 1,
                WeeeCategory = 1,
                LocationType = 1,
                LocationApprovalNumber = "AE1",
                Tonnage = 123.456m
            });

            GetSchemeWeeeCsvHandler handler = new GetSchemeWeeeCsvHandler(
                A.Dummy<IStoredProcedures>(),
                A.Dummy<IWeeeAuthorization>(),
                A.Dummy<CsvWriterFactory>());

            // Act
            IEnumerable<GetSchemeWeeeCsvHandler.CsvResult> results = handler.CreateResults(
                data,
                new List<string>() { "AATF1" },
                new List<string>() { "AE1" });

            // Assert
            GetSchemeWeeeCsvHandler.CsvResult result1 = results.First();
            Assert.Equal(123.456m, result1.AeTonnage["AE1"]);
            Assert.Equal(123.456m, result1.TotalDelivered);
        }
        public void CreateResults_WithNoDeliveredAmounts_PopulatesTotalAsNull()
        {
            // Arrange
            SpgSchemeWeeeCsvResult data = new SpgSchemeWeeeCsvResult();
            data.Schemes.Add(new SpgSchemeWeeeCsvResult.SchemeResult
            {
                SchemeId = Guid.NewGuid()
            });

            GetSchemeWeeeCsvHandler handler = new GetSchemeWeeeCsvHandler(
                A.Dummy<IStoredProcedures>(),
                A.Dummy<IWeeeAuthorization>(),
                A.Dummy<CsvWriterFactory>());

            // Act
            IEnumerable<GetSchemeWeeeCsvHandler.CsvResult> results = handler.CreateResults(
                data,
                new List<string>() { "AATF1" },
                new List<string>() { "AE1" });

            // Assert
            GetSchemeWeeeCsvHandler.CsvResult result1 = results.First();
            Assert.Equal(null, result1.TotalDelivered);
        }
        public void CreateResults_WithCollectedAmountWithSourceType2_PopulatesFinalHoldersWithValue()
        {
            // Arrange
            SpgSchemeWeeeCsvResult data = new SpgSchemeWeeeCsvResult();

            data.Schemes.Add(new SpgSchemeWeeeCsvResult.SchemeResult()
            {
                SchemeId = new Guid("3E299215-BA37-403F-B398-EB345371F3D2")
            });

            data.CollectedAmounts.Add(new SpgSchemeWeeeCsvResult.CollectedAmountResult()
            {
                SchemeId = new Guid("3E299215-BA37-403F-B398-EB345371F3D2"),
                QuarterType = 1,
                WeeeCategory = 1,
                SourceType = 2,
                Tonnage = 123.456m
            });

            GetSchemeWeeeCsvHandler handler = new GetSchemeWeeeCsvHandler(
                A.Dummy<IStoredProcedures>(),
                A.Dummy<IWeeeAuthorization>(),
                A.Dummy<CsvWriterFactory>());

            // Act
            IEnumerable<GetSchemeWeeeCsvHandler.CsvResult> results = handler.CreateResults(
                data,
                A.Dummy<IEnumerable<string>>(),
                A.Dummy<IEnumerable<string>>());

            // Assert
            GetSchemeWeeeCsvHandler.CsvResult result1 = results.First();
            Assert.Equal(123.456m, result1.FinalHolders);
        }
        public void CreateResults_WithNoCollectedAmounts_PopulatesFinalHoldersAsNull()
        {
            // Arrange
            SpgSchemeWeeeCsvResult data = new SpgSchemeWeeeCsvResult();
            data.Schemes.Add(new SpgSchemeWeeeCsvResult.SchemeResult
            {
                SchemeId = Guid.NewGuid()
            });

            GetSchemeWeeeCsvHandler handler = new GetSchemeWeeeCsvHandler(
                A.Dummy<IStoredProcedures>(),
                A.Dummy<IWeeeAuthorization>(),
                A.Dummy<CsvWriterFactory>());

            // Act
            IEnumerable<GetSchemeWeeeCsvHandler.CsvResult> results = handler.CreateResults(
                data,
                A.Dummy<IEnumerable<string>>(),
                A.Dummy<IEnumerable<string>>());

            // Assert
            GetSchemeWeeeCsvHandler.CsvResult result1 = results.First();
            Assert.Equal(null, result1.FinalHolders);
        }
        public void CreateResults_WithDeliveredAmountsForVariousSchemesCategoriesAndQuarters_SumsAmountsAndPopulatesTotals()
        {
            // Arrange
            SpgSchemeWeeeCsvResult data = new SpgSchemeWeeeCsvResult();

            data.Schemes.Add(new SpgSchemeWeeeCsvResult.SchemeResult()
            {
                SchemeId   = new Guid("3E299215-BA37-403F-B398-EB345371F3D2"),
                SchemeName = "Scheme 1"
            });

            data.Schemes.Add(new SpgSchemeWeeeCsvResult.SchemeResult()
            {
                SchemeId   = new Guid("9E1EE29C-5FFD-4137-BA55-98C0F0F7212D"),
                SchemeName = "Scheme 2"
            });

            data.DeliveredAmounts.Add(new SpgSchemeWeeeCsvResult.DeliveredAmountResult()
            {
                SchemeId               = new Guid("3E299215-BA37-403F-B398-EB345371F3D2"),
                QuarterType            = 1,
                WeeeCategory           = 1,
                LocationType           = 0,
                LocationApprovalNumber = "AATF1",
                Tonnage = 1
            });

            data.DeliveredAmounts.Add(new SpgSchemeWeeeCsvResult.DeliveredAmountResult()
            {
                SchemeId               = new Guid("3E299215-BA37-403F-B398-EB345371F3D2"),
                QuarterType            = 1,
                WeeeCategory           = 1,
                LocationType           = 1,
                LocationApprovalNumber = "AE1",
                Tonnage = 2
            });

            data.DeliveredAmounts.Add(new SpgSchemeWeeeCsvResult.DeliveredAmountResult()
            {
                SchemeId               = new Guid("3E299215-BA37-403F-B398-EB345371F3D2"),
                QuarterType            = 4,
                WeeeCategory           = 1,
                LocationType           = 1,
                LocationApprovalNumber = "AE1",
                Tonnage = 9999
            });

            data.DeliveredAmounts.Add(new SpgSchemeWeeeCsvResult.DeliveredAmountResult()
            {
                SchemeId               = new Guid("3E299215-BA37-403F-B398-EB345371F3D2"),
                QuarterType            = 1,
                WeeeCategory           = 14,
                LocationType           = 1,
                LocationApprovalNumber = "AE1",
                Tonnage = 9999
            });

            data.DeliveredAmounts.Add(new SpgSchemeWeeeCsvResult.DeliveredAmountResult()
            {
                SchemeId               = new Guid("9E1EE29C-5FFD-4137-BA55-98C0F0F7212D"),
                QuarterType            = 1,
                WeeeCategory           = 1,
                LocationType           = 1,
                LocationApprovalNumber = "AE1",
                Tonnage = 9999
            });

            GetSchemeWeeeCsvHandler handler = new GetSchemeWeeeCsvHandler(
                A.Dummy <IStoredProcedures>(),
                A.Dummy <IWeeeAuthorization>(),
                A.Dummy <CsvWriterFactory>());

            // Act
            IEnumerable <GetSchemeWeeeCsvHandler.CsvResult> results = handler.CreateResults(
                data,
                new List <string>()
            {
                "AATF1"
            },
                new List <string>()
            {
                "AE1"
            });

            // Assert
            GetSchemeWeeeCsvHandler.CsvResult result1 = results.First();
            Assert.Equal(3, result1.TotalDelivered);
        }
        public async Task HandleAsync_WithSchemeSpecified_GeneratesCorrectFileName()
        {
            IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();

            IStoredProcedures storedProcedures = A.Fake<IStoredProcedures>();

            SpgSchemeWeeeCsvResult storedProcedureResult = new SpgSchemeWeeeCsvResult();
            storedProcedureResult.Schemes.Add(new SpgSchemeWeeeCsvResult.SchemeResult()
            {
                SchemeId = new Guid("C5AD2FF9-941D-4D6F-B68B-9805DD7E1FD1"),
                ApprovalNumber = "WEE/AA1111AA/SCH"
            });

            A.CallTo(() => storedProcedures.SpgSchemeWeeeCsvAsync(A<int>._, A<Guid?>._, A<string>._))
                .Returns(storedProcedureResult);

            GetSchemeWeeeCsvHandler handler = new GetSchemeWeeeCsvHandler(
                storedProcedures,
                authorization,
                A.Dummy<CsvWriterFactory>());

            GetSchemeWeeeCsv request = new GetSchemeWeeeCsv(2016, new Guid("C5AD2FF9-941D-4D6F-B68B-9805DD7E1FD1"), ObligationType.B2C);

            // Act
            SystemTime.Freeze(new DateTime(2016, 12, 31, 23, 59, 0));
            FileInfo result = await handler.HandleAsync(request);
            SystemTime.Unfreeze();

            // Assert
            Assert.Equal("2016_WEEAA1111AASCH_B2C_schemeWEEE_31122016_2359.csv", result.FileName);
        }
        public void CreateResults_WithOneScheme_CreatesAResultForEachCategoryAndEachQuarter()
        {
            // Arrange
            SpgSchemeWeeeCsvResult data = new SpgSchemeWeeeCsvResult();
            data.Schemes.Add(new SpgSchemeWeeeCsvResult.SchemeResult
            {
                SchemeId = Guid.NewGuid()
            });

            GetSchemeWeeeCsvHandler handler = new GetSchemeWeeeCsvHandler(
                A.Dummy<IStoredProcedures>(),
                A.Dummy<IWeeeAuthorization>(),
                A.Dummy<CsvWriterFactory>());

            // Act
            IEnumerable<GetSchemeWeeeCsvHandler.CsvResult> results = handler.CreateResults(
                data,
                A.Dummy<IEnumerable<string>>(),
                A.Dummy<IEnumerable<string>>());

            // Assert
            Assert.Equal(56, results.Count());
            Assert.Collection(results.Take(15), // Just examine the first 15 rows
                r => { Assert.Equal(1, r.Category); Assert.Equal(1, r.QuarterType); },
                r => { Assert.Equal(2, r.Category); Assert.Equal(1, r.QuarterType); },
                r => { Assert.Equal(3, r.Category); Assert.Equal(1, r.QuarterType); },
                r => { Assert.Equal(4, r.Category); Assert.Equal(1, r.QuarterType); },
                r => { Assert.Equal(5, r.Category); Assert.Equal(1, r.QuarterType); },
                r => { Assert.Equal(6, r.Category); Assert.Equal(1, r.QuarterType); },
                r => { Assert.Equal(7, r.Category); Assert.Equal(1, r.QuarterType); },
                r => { Assert.Equal(8, r.Category); Assert.Equal(1, r.QuarterType); },
                r => { Assert.Equal(9, r.Category); Assert.Equal(1, r.QuarterType); },
                r => { Assert.Equal(10, r.Category); Assert.Equal(1, r.QuarterType); },
                r => { Assert.Equal(11, r.Category); Assert.Equal(1, r.QuarterType); },
                r => { Assert.Equal(12, r.Category); Assert.Equal(1, r.QuarterType); },
                r => { Assert.Equal(13, r.Category); Assert.Equal(1, r.QuarterType); },
                r => { Assert.Equal(14, r.Category); Assert.Equal(1, r.QuarterType); },
                r => { Assert.Equal(1, r.Category); Assert.Equal(2, r.QuarterType); });
            // etc...
        }
        public async Task Execute_WithoutSchemeFilter_ReturnsResultsForAllSchemes()
        {
            using (DatabaseWrapper wrapper = new DatabaseWrapper())
            {
                // Arrange
                Domain.Organisation.Organisation organisation = Domain.Organisation.Organisation.CreateSoleTrader("Test Organisation");
                Domain.UKCompetentAuthority      authority    = wrapper.WeeeContext.UKCompetentAuthorities.Single(c => c.Abbreviation == UKCompetentAuthorityAbbreviationType.EA);
                Quarter quarter = new Quarter(2099, QuarterType.Q1);

                // Arrange - Scheme 1

                Domain.Scheme.Scheme scheme1 = new Domain.Scheme.Scheme(organisation);
                scheme1.UpdateScheme("Test Scheme 1", "WEE/AH7453NF/SCH", "WEE9462846", Domain.Obligation.ObligationType.B2C, authority);
                scheme1.SetStatus(Domain.Scheme.SchemeStatus.Approved);

                Domain.DataReturns.DataReturn dataReturn1 = new Domain.DataReturns.DataReturn(scheme1, quarter);

                Domain.DataReturns.DataReturnVersion version1 = new Domain.DataReturns.DataReturnVersion(dataReturn1);

                Domain.DataReturns.WeeeCollectedAmount amount1 = new Domain.DataReturns.WeeeCollectedAmount(
                    WeeeCollectedAmountSourceType.Dcf,
                    Domain.Obligation.ObligationType.B2C,
                    WeeeCategory.LargeHouseholdAppliances,
                    123.456m);

                version1.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(amount1);

                wrapper.WeeeContext.DataReturnVersions.Add(version1);

                await wrapper.WeeeContext.SaveChangesAsync();

                dataReturn1.SetCurrentVersion(version1);

                await wrapper.WeeeContext.SaveChangesAsync();

                // Arrange - Scheme 2

                Domain.Scheme.Scheme scheme2 = new Domain.Scheme.Scheme(organisation);
                scheme2.UpdateScheme("Test Scheme 2", "WEE/ZU6355HV/SCH", "WEE5746395", Domain.Obligation.ObligationType.B2C, authority);
                scheme2.SetStatus(Domain.Scheme.SchemeStatus.Approved);

                Domain.DataReturns.DataReturn dataReturn2 = new Domain.DataReturns.DataReturn(scheme2, quarter);

                Domain.DataReturns.DataReturnVersion version2 = new Domain.DataReturns.DataReturnVersion(dataReturn2);

                Domain.DataReturns.WeeeCollectedAmount amount2 = new Domain.DataReturns.WeeeCollectedAmount(
                    WeeeCollectedAmountSourceType.Dcf,
                    Domain.Obligation.ObligationType.B2C,
                    WeeeCategory.LargeHouseholdAppliances,
                    123.456m);

                version2.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(amount2);

                wrapper.WeeeContext.DataReturnVersions.Add(version2);

                await wrapper.WeeeContext.SaveChangesAsync();

                dataReturn2.SetCurrentVersion(version2);

                await wrapper.WeeeContext.SaveChangesAsync();

                // Act
                SpgSchemeWeeeCsvResult result = await wrapper.WeeeContext.StoredProcedures.SpgSchemeWeeeCsvAsync(
                    2099,
                    null,
                    "B2C");

                // Assert
                Assert.NotNull(result);

                Assert.NotNull(result.Schemes);
                Assert.Equal(2, result.Schemes.Count);

                Assert.NotNull(result.CollectedAmounts);
                Assert.Equal(2, result.CollectedAmounts.Count);
            }
        }
Example #18
0
        public IEnumerable <CsvResult> CreateResults(SpgSchemeWeeeCsvResult results, IEnumerable <string> aatfLocations, IEnumerable <string> aaeLocations)
        {
            var csvResults = new List <CsvResult>();

            var collectedAmountsDictionary = new Dictionary <WeeeAmountKey, IEnumerable <SpgSchemeWeeeCsvResult.CollectedAmountResult> >();
            var deliveredAmountsDictionary = new Dictionary <WeeeAmountKey, IEnumerable <SpgSchemeWeeeCsvResult.DeliveredAmountResult> >();

            foreach (var quarterType in Enumerable.Range(1, 4))
            {
                foreach (var category in Enumerable.Range(1, 14))
                {
                    foreach (var scheme in results.Schemes)
                    {
                        var key = new WeeeAmountKey(category, quarterType, scheme.SchemeId);

                        collectedAmountsDictionary.Add(key, results.CollectedAmounts
                                                       .Where(ca => ca.QuarterType == key.QuarterType &&
                                                              ca.WeeeCategory == key.Category &&
                                                              ca.SchemeId == key.SchemeId));

                        deliveredAmountsDictionary.Add(key, results.DeliveredAmounts
                                                       .Where(ca => ca.QuarterType == key.QuarterType &&
                                                              ca.WeeeCategory == key.Category &&
                                                              ca.SchemeId == key.SchemeId));
                    }
                }
            }

            foreach (var key in collectedAmountsDictionary.Keys)
            {
                var collectedAmounts = collectedAmountsDictionary[key].ToList();
                var deliveredAmounts = deliveredAmountsDictionary[key].ToList();
                var scheme           = results.Schemes.Single(s => s.SchemeId == key.SchemeId);

                var aatfTonnage = aatfLocations
                                  .Select(l => new
                {
                    Location = l,
                    Tonnage  = deliveredAmounts
                               .Where(da => da.LocationType == 0)
                               .Where(da => da.LocationApprovalNumber == l)
                               .Select(da => (decimal?)da.Tonnage)
                               .SingleOrDefault()
                })
                                  .ToDictionary(a => a.Location, a => a.Tonnage);

                var aaeTonnage = aaeLocations
                                 .Select(l => new
                {
                    Location = l,
                    Tonnage  = deliveredAmounts
                               .Where(da => da.LocationType == 1)
                               .Where(da => da.LocationApprovalNumber == l)
                               .Select(da => (decimal?)da.Tonnage)
                               .SingleOrDefault()
                })
                                 .ToDictionary(a => a.Location, a => a.Tonnage);

                var dcf = collectedAmounts
                          .Where(ca => ca.SourceType == (int)WeeeCollectedAmountSourceType.Dcf)
                          .Select(ca => (decimal?)ca.Tonnage)
                          .SingleOrDefault();

                var distributors = collectedAmounts
                                   .Where(ca => ca.SourceType == (int)WeeeCollectedAmountSourceType.Distributor)
                                   .Select(ca => (decimal?)ca.Tonnage)
                                   .SingleOrDefault();

                var finalHolders = collectedAmounts
                                   .Where(ca => ca.SourceType == (int)WeeeCollectedAmountSourceType.FinalHolder)
                                   .Select(ca => (decimal?)ca.Tonnage)
                                   .SingleOrDefault();

                csvResults.Add(new CsvResult
                {
                    AatfTonnage          = aatfTonnage,
                    AeTonnage            = aaeTonnage,
                    QuarterType          = key.QuarterType,
                    Category             = key.Category,
                    Dcf                  = dcf,
                    Distributors         = distributors,
                    FinalHolders         = finalHolders,
                    SchemeName           = scheme.SchemeName,
                    SchemeApprovalNumber = scheme.ApprovalNumber,
                    TotalDelivered       = deliveredAmounts.Any()
                        ? deliveredAmounts.Sum(da => da.Tonnage)
                        : (decimal?)null
                });
            }

            return(csvResults.OrderBy(r => r.SchemeName));
        }