public async Task<List<ErrorData>> Validate(string producerRegistrationNumber, string producerName,
            WeeeCategory category, ObligationType obligationType, decimal tonnage)
        {
            List<ErrorData> errorsAndWarnings = new List<ErrorData>();

            RegisteredProducer producer = await schemeQuarterDataAccess.GetRegisteredProducer(producerRegistrationNumber);

            // If producer is null, add an error as it is not registered with the current scheme for the compliance year.
            if (producer == null)
            {
                var errorMessage = string.Format(
                    "The producer with producer registration number {0} is not a registered member of your producer compliance scheme for {1}. "
                    + "Remove this producer from your return, or ensure they are a registered member of your scheme.",
                    producerRegistrationNumber,
                    quarter.Year);

                errorsAndWarnings.Add(new ErrorData(errorMessage, ErrorLevel.Error));
            }
            else
            {
                errorsAndWarnings.AddIfNotDefault(ValidateProducerName(producer, producerRegistrationNumber, producerName));
                errorsAndWarnings.AddIfNotDefault(ValidateProducerObligationType(producer, producerRegistrationNumber, producerName, obligationType));
            }

            return errorsAndWarnings;
        }
Example #2
0
        private void GetDeliveredTotals(
            IEnumerable <DataReturn> dataReturns,
            Domain.Obligation.ObligationType obligationType,
            WeeeCategory category,
            out decimal?totalQ1,
            out decimal?totalQ2,
            out decimal?totalQ3,
            out decimal?totalQ4,
            out decimal?total)
        {
            total = null;

            var amountsQ1 = GetDeliveredAmounts(dataReturns, obligationType, category, QuarterType.Q1);

            if (amountsQ1.Any())
            {
                totalQ1 = amountsQ1.Sum(x => x.Tonnage);
                total   = (total ?? 0) + totalQ1;
            }
            else
            {
                totalQ1 = null;
            }

            var amountsQ2 = GetDeliveredAmounts(dataReturns, obligationType, category, QuarterType.Q2);

            if (amountsQ2.Any())
            {
                totalQ2 = amountsQ2.Sum(x => x.Tonnage);
                total   = (total ?? 0) + totalQ2;
            }
            else
            {
                totalQ2 = null;
            }

            var amountsQ3 = GetDeliveredAmounts(dataReturns, obligationType, category, QuarterType.Q3);

            if (amountsQ3.Any())
            {
                totalQ3 = amountsQ3.Sum(x => x.Tonnage);
                total   = (total ?? 0) + totalQ3;
            }
            else
            {
                totalQ3 = null;
            }

            var amountsQ4 = GetDeliveredAmounts(dataReturns, obligationType, category, QuarterType.Q4);

            if (amountsQ4.Any())
            {
                totalQ4 = amountsQ4.Sum(x => x.Tonnage);
                total   = (total ?? 0) + totalQ4;
            }
            else
            {
                totalQ4 = null;
            }
        }
        public async Task <List <ErrorData> > Validate(string producerRegistrationNumber, string producerName,
                                                       WeeeCategory category, ObligationType obligationType, decimal tonnage)
        {
            List <ErrorData> errorsAndWarnings = new List <ErrorData>();

            RegisteredProducer producer = await schemeQuarterDataAccess.GetRegisteredProducer(producerRegistrationNumber);

            // If producer is null, add an error as it is not registered with the current scheme for the compliance year.
            if (producer == null)
            {
                var errorMessage = string.Format(
                    "The producer with producer registration number {0} is not a registered member of your producer compliance scheme for {1}. "
                    + "Remove this producer from your return, or ensure they are a registered member of your scheme.",
                    producerRegistrationNumber,
                    quarter.Year);

                errorsAndWarnings.Add(new ErrorData(errorMessage, ErrorLevel.Error));
            }
            else
            {
                errorsAndWarnings.AddIfNotDefault(ValidateProducerName(producer, producerRegistrationNumber, producerName));
                errorsAndWarnings.AddIfNotDefault(ValidateProducerObligationType(producer, producerRegistrationNumber, producerName, obligationType));
            }

            return(errorsAndWarnings);
        }
Example #4
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));
 }
Example #5
0
 public CsvResult(
     WeeeCategory category,
     Domain.Obligation.ObligationType obligationType,
     decimal?dcfTotal,
     decimal?dcfQ1,
     decimal?dcfQ2,
     decimal?dcfQ3,
     decimal?dcfQ4,
     decimal?distributorTotal,
     decimal?distributorQ1,
     decimal?distributorQ2,
     decimal?distributorQ3,
     decimal?distributorQ4,
     decimal?finalHolderTotal,
     decimal?finalHolderQ1,
     decimal?finalHolderQ2,
     decimal?finalHolderQ3,
     decimal?finalHolderQ4,
     decimal?deliveredTotal,
     decimal?deliveredQ1,
     decimal?deliveredQ2,
     decimal?deliveredQ3,
     decimal?deliveredQ4)
 {
     Category         = category;
     ObligationType   = obligationType;
     DcfTotal         = dcfTotal;
     DcfQ1            = dcfQ1;
     DcfQ2            = dcfQ2;
     DcfQ3            = dcfQ3;
     DcfQ4            = dcfQ4;
     DistributorTotal = distributorTotal;
     DistributorQ1    = distributorQ1;
     DistributorQ2    = distributorQ2;
     DistributorQ3    = distributorQ3;
     DistributorQ4    = distributorQ4;
     FinalHolderTotal = finalHolderTotal;
     FinalHolderQ1    = finalHolderQ1;
     FinalHolderQ2    = finalHolderQ2;
     FinalHolderQ3    = finalHolderQ3;
     FinalHolderQ4    = finalHolderQ4;
     DeliveredTotal   = deliveredTotal;
     DeliveredQ1      = deliveredQ1;
     DeliveredQ2      = deliveredQ2;
     DeliveredQ3      = deliveredQ3;
     DeliveredQ4      = deliveredQ4;
 }
        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 ErrorData ValidateProducerObligationType(RegisteredProducer producer, string producerRegistrationNumber, string producerName, ObligationType obligationType)
        {
            ErrorData error = null;

            if (!producer.CurrentSubmission.ObligationType.HasFlag(obligationType))
            {
                var errorMessage = string.Format(
                "Producer registration number {0} {1} has submitted a {2} return for one or more categories but is only registered for {3}. Amend the return or submit an update for the producer's details.",
                producerRegistrationNumber,
                producerName,
                obligationType,
                producer.CurrentSubmission.ObligationType);

                error = new ErrorData(errorMessage, ErrorLevel.Error);
            }

            return error;
        }
        private async Task CreateScheme(DatabaseWrapper db)
        {
            const Domain.Obligation.ObligationType obligationType = Domain.Obligation.ObligationType.B2B;

            var contact = new Domain.Organisation.Contact("firstName", "LastName", "Position");

            Organisation organisation = Organisation.CreateSoleTrader("Test Organisation");
            var          address      = new Address("address1", "address2", "town", "county", "postcode", db.WeeeContext.Countries.First(), "telephone", "email");

            organisation.AddOrUpdateAddress(Domain.AddressType.RegisteredOrPPBAddress, address);

            Domain.UKCompetentAuthority authority = db.WeeeContext.UKCompetentAuthorities.Single(c => c.Abbreviation == UKCompetentAuthorityAbbreviationType.EA);

            Scheme scheme1 = new Scheme(organisation);

            scheme1.UpdateScheme("BBB", "TT", "Test", obligationType, authority);
            scheme1.AddOrUpdateMainContactPerson(contact);
            scheme1.AddOrUpdateAddress(address);
            db.WeeeContext.Organisations.Add(organisation);
            db.WeeeContext.Schemes.Add(scheme1);
            await db.WeeeContext.SaveChangesAsync();
        }
Example #9
0
        public async Task <CreateOrUpdateSchemeInformationResult> HandleAsync(CreateScheme message)
        {
            authorization.EnsureCanAccessInternalArea();

            Scheme scheme = new Scheme(message.OrganisationId);

            this.dataAccess.AddScheme(scheme);

            /*
             * Check the uniqueness of the approval number if the value is being changed.
             */
            if (await dataAccess.CheckSchemeApprovalNumberInUseAsync(message.ApprovalNumber))
            {
                return(new CreateOrUpdateSchemeInformationResult()
                {
                    Result = CreateOrUpdateSchemeInformationResult.ResultType.ApprovalNumberUniquenessFailure
                });
            }

            UKCompetentAuthority environmentAgency = await dataAccess.FetchEnvironmentAgencyAsync();

            if (environmentAgency.Id == message.CompetentAuthorityId)
            {
                // The 1B1S customer reference is mandatory for schemes in the Environmetn Agency.
                if (string.IsNullOrEmpty(message.IbisCustomerReference))
                {
                    return(new CreateOrUpdateSchemeInformationResult()
                    {
                        Result = CreateOrUpdateSchemeInformationResult.ResultType.IbisCustomerReferenceMandatoryForEAFailure,
                    });
                }
                else
                {
                    /*
                     * The 1B1S customer refernece must be unique across schemes within the Environment Agency.
                     *
                     * Try and find another non-rejected scheme for the Environment Agency with the same
                     * 1B1S customer reference. In production, this should at most only ever return one result.
                     *
                     * As the check for uniqueness has not always existed, it is possible that other
                     * environments may contain multiple schemes with the same 1B1S customer reference
                     * so we are using FirstOrDefault rather than SingleOrDefault.
                     */
                    List <Scheme> nonRejectedEnvironmentAgencySchemes = await dataAccess.FetchNonRejectedEnvironmentAgencySchemesAsync();

                    Scheme otherScheme = nonRejectedEnvironmentAgencySchemes
                                         .Where(s => s.Id != scheme.Id)
                                         .Where(s => s.IbisCustomerReference == message.IbisCustomerReference)
                                         .FirstOrDefault();

                    if (otherScheme != null)
                    {
                        return(new CreateOrUpdateSchemeInformationResult()
                        {
                            Result = CreateOrUpdateSchemeInformationResult.ResultType.IbisCustomerReferenceUniquenessFailure,
                            IbisCustomerReferenceUniquenessFailure = new CreateOrUpdateSchemeInformationResult.IbisCustomerReferenceUniquenessFailureInfo()
                            {
                                IbisCustomerReference = message.IbisCustomerReference,
                                OtherSchemeApprovalNumber = otherScheme.ApprovalNumber,
                                OtherSchemeName = otherScheme.SchemeName
                            }
                        });
                    }
                }
            }

            Domain.Obligation.ObligationType obligationType = ValueObjectInitializer.GetObligationType(message.ObligationType);
            scheme.UpdateScheme(
                message.SchemeName,
                message.ApprovalNumber,
                message.IbisCustomerReference,
                obligationType,
                message.CompetentAuthorityId);

            SchemeStatus status = message.Status.ToDomainEnumeration <SchemeStatus>();

            scheme.SetStatus(status);

            await dataAccess.SaveAsync();

            Organisation org = await organisationDataAccess.FetchOrganisationAsync(message.OrganisationId);

            if (org.OrganisationStatus == OrganisationStatus.Incomplete)
            {
                org.CompleteRegistration();
                await organisationDataAccess.SaveAsync();
            }

            return(new CreateOrUpdateSchemeInformationResult()
            {
                Result = CreateOrUpdateSchemeInformationResult.ResultType.Success
            });
        }
        public void ValidateProducerObligationType_WithIncorrectObligationType_ReturnsError(ObligationType registeredObligationType, ObligationType eeeObligationType)
        {
            // Arrange
            var builder = new EeeValidatorBuilder();

            var producerSubmission = A.Fake<ProducerSubmission>();
            A.CallTo(() => producerSubmission.ObligationType)
                .Returns(registeredObligationType);

            var registeredProducer = A.Fake<RegisteredProducer>();
            A.CallTo(() => registeredProducer.CurrentSubmission)
                .Returns(producerSubmission);

            // Act
            var error = builder.Build().ValidateProducerObligationType(registeredProducer, "PRN1234", "TestProducerName", eeeObligationType);

            // Assert
            Assert.NotNull(error);
            Assert.Equal(ErrorLevel.Error, error.ErrorLevel);
            Assert.Contains("for one or more categories but is only registered for", error.Description);
            Assert.Contains("PRN1234", error.Description);
            Assert.Contains("TestProducerName", error.Description);
            Assert.Contains(eeeObligationType.ToString(), error.Description);
            Assert.Contains(registeredObligationType.ToString(), error.Description);
        }
        public void ValidateProducerObligationType_WithCorrectObligationType_DoesNotReturnError(ObligationType registeredObligationType, ObligationType eeeObligationType)
        {
            // Arrange
            var builder = new EeeValidatorBuilder();

            var producerSubmission = A.Fake<ProducerSubmission>();
            A.CallTo(() => producerSubmission.ObligationType)
                .Returns(registeredObligationType);

            var registeredProducer = A.Fake<RegisteredProducer>();
            A.CallTo(() => registeredProducer.CurrentSubmission)
                .Returns(producerSubmission);

            // Act
            var error = builder.Build().ValidateProducerObligationType(registeredProducer, A.Dummy<string>(), A.Dummy<string>(), eeeObligationType);

            // Assert
            Assert.Null(error);
        }
Example #12
0
 public Task <List <ErrorData> > InvokeValidate(string producerRegistrationNumber = "Test PRN", string producerName = "Test Producer Name",
                                                ObligationType obligationType     = ObligationType.B2B)
 {
     return(Build().Validate(producerRegistrationNumber, producerName, A.Dummy <WeeeCategory>(), obligationType, A.Dummy <decimal>()));
 }
Example #13
0
        public void ValidateProducerObligationType_WithCorrectObligationType_DoesNotReturnError(ObligationType registeredObligationType, ObligationType eeeObligationType)
        {
            // Arrange
            var builder = new EeeValidatorBuilder();

            var producerSubmission = A.Fake <ProducerSubmission>();

            A.CallTo(() => producerSubmission.ObligationType)
            .Returns(registeredObligationType);

            var registeredProducer = A.Fake <RegisteredProducer>();

            A.CallTo(() => registeredProducer.CurrentSubmission)
            .Returns(producerSubmission);

            // Act
            var error = builder.Build().ValidateProducerObligationType(registeredProducer, A.Dummy <string>(), A.Dummy <string>(), eeeObligationType);

            // Assert
            Assert.Null(error);
        }
Example #14
0
        public void ValidateProducerObligationType_WithIncorrectObligationType_ReturnsError(ObligationType registeredObligationType, ObligationType eeeObligationType)
        {
            // Arrange
            var builder = new EeeValidatorBuilder();

            var producerSubmission = A.Fake <ProducerSubmission>();

            A.CallTo(() => producerSubmission.ObligationType)
            .Returns(registeredObligationType);

            var registeredProducer = A.Fake <RegisteredProducer>();

            A.CallTo(() => registeredProducer.CurrentSubmission)
            .Returns(producerSubmission);

            // Act
            var error = builder.Build().ValidateProducerObligationType(registeredProducer, "PRN1234", "TestProducerName", eeeObligationType);

            // Assert
            Assert.NotNull(error);
            Assert.Equal(ErrorLevel.Error, error.ErrorLevel);
            Assert.Contains("for one or more categories but is only registered for", error.Description);
            Assert.Contains("PRN1234", error.Description);
            Assert.Contains("TestProducerName", error.Description);
            Assert.Contains(eeeObligationType.ToString(), error.Description);
            Assert.Contains(registeredObligationType.ToString(), error.Description);
        }
 public Task<List<ErrorData>> InvokeValidate(string producerRegistrationNumber = "Test PRN", string producerName = "Test Producer Name",
     ObligationType obligationType = ObligationType.B2B)
 {
     return Build().Validate(producerRegistrationNumber, producerName, A.Dummy<WeeeCategory>(), obligationType, A.Dummy<decimal>());
 }
        public async Task AddAeDeliveredAmount(string approvalNumber, string operatorName, WeeeCategory category, ObligationType obligationType, decimal tonnage)
        {
            var aeDeliveryLocation = await schemeQuarterDataAccess.GetOrAddAeDeliveryLocation(approvalNumber, operatorName);

            weeeDeliveredAmounts.Add(new WeeeDeliveredAmount(obligationType, category, tonnage, aeDeliveryLocation));
        }
        public async Task AddEeeOutputAmount(string producerRegistrationNumber, string producerName, WeeeCategory category, ObligationType obligationType, decimal tonnage)
        {
            var validationResult = await eeeValidator.Validate(producerRegistrationNumber, producerName, category, obligationType, tonnage);

            if (ConsideredValid(validationResult))
            {
                var registeredProducer = await schemeQuarterDataAccess.GetRegisteredProducer(producerRegistrationNumber);

                eeeOutputAmounts.Add(new EeeOutputAmount(obligationType, category, tonnage, registeredProducer));
            }

            Errors.AddRange(validationResult);
        }
        public ErrorData ValidateProducerObligationType(RegisteredProducer producer, string producerRegistrationNumber, string producerName, ObligationType obligationType)
        {
            ErrorData error = null;

            if (!producer.CurrentSubmission.ObligationType.HasFlag(obligationType))
            {
                var errorMessage = string.Format(
                    "Producer registration number {0} {1} has submitted a {2} return for one or more categories but is only registered for {3}. Amend the return or submit an update for the producer's details.",
                    producerRegistrationNumber,
                    producerName,
                    obligationType,
                    producer.CurrentSubmission.ObligationType);

                error = new ErrorData(errorMessage, ErrorLevel.Error);
            }

            return(error);
        }
        public Task AddWeeeCollectedAmount(WeeeCollectedAmountSourceType sourceType, WeeeCategory category, ObligationType obligationType, decimal tonnage)
        {
            weeeCollectedAmounts.Add(new WeeeCollectedAmount(sourceType, obligationType, category, tonnage));

            return(Task.Delay(0));
        }