public async Task FetchSchemeAsync_ReturnsSchemeWithSpecifiedOrganisationId()
{
using (DatabaseWrapper database = new DatabaseWrapper())
{
// Arrange
var modelHelper = new ModelHelper(database.Model);
var organisationId = new Guid("C826DCE8-78EB-4BE4-B419-4DE73D1AD181");
var organisation = modelHelper.CreateOrganisation();
organisation.Id = organisationId;
modelHelper.CreateScheme(organisation);
database.Model.SaveChanges();
OrganisationDetailsDataAccess dataAccess = new OrganisationDetailsDataAccess(database.WeeeContext);
// Act
Domain.Scheme.Scheme result = await dataAccess.FetchSchemeAsync(organisationId);
// Assert
Assert.NotNull(result);
Assert.Equal(organisationId, result.OrganisationId);
}
}
public async Task RemoveRegisteredProducer_ProducerIsMarkedAsRemovedAndRemovedDateIsSet()
{
using (DatabaseWrapper database = new DatabaseWrapper())
{
var context = database.WeeeContext;
var organisation = Organisation.CreateSoleTrader("My trading name");
context.Organisations.Add(organisation);
await context.SaveChangesAsync();
var scheme = new Scheme(organisation.Id);
context.Schemes.Add(scheme);
await context.SaveChangesAsync();
var producer = new RegisteredProducer("ABC12345", 2017, scheme);
context.AllRegisteredProducers.Add(producer);
SystemTime.Freeze(new DateTime(2016, 10, 1));
producer.Remove();
SystemTime.Unfreeze();
await context.SaveChangesAsync();
producer = context.AllRegisteredProducers
.SingleOrDefault(p => p.Id == producer.Id);
Assert.NotNull(producer);
Assert.True(producer.Removed);
Assert.NotNull(producer.RemovedDate);
Assert.Equal(new DateTime(2016, 10, 1), producer.RemovedDate);
}
}
public async Task CreateRegisteredProducer_ProducerIsNotRemoved()
{
using (DatabaseWrapper database = new DatabaseWrapper())
{
var context = database.WeeeContext;
var organisation = Organisation.CreateSoleTrader("My trading name");
context.Organisations.Add(organisation);
await context.SaveChangesAsync();
var scheme = new Scheme(organisation.Id);
context.Schemes.Add(scheme);
await context.SaveChangesAsync();
var producer = new RegisteredProducer("ABC12345", 2017, scheme);
context.AllRegisteredProducers.Add(producer);
await context.SaveChangesAsync();
producer = context.RegisteredProducers
.SingleOrDefault(p => p.Id == producer.Id);
Assert.NotNull(producer);
Assert.False(producer.Removed);
Assert.Null(producer.RemovedDate);
}
}
public async Task RemoveRegisteredProducer_ProducerIsMarkedAsRemovedAndRemovedDateIsSet()
{
using (DatabaseWrapper database = new DatabaseWrapper())
{
var context = database.WeeeContext;
var organisation = Organisation.CreateSoleTrader("My trading name");
context.Organisations.Add(organisation);
await context.SaveChangesAsync();
var scheme = new Scheme(organisation.Id);
context.Schemes.Add(scheme);
await context.SaveChangesAsync();
var producer = new RegisteredProducer("ABC12345", 2017, scheme);
context.AllRegisteredProducers.Add(producer);
SystemTime.Freeze(new DateTime(2016, 10, 1));
producer.Remove();
SystemTime.Unfreeze();
await context.SaveChangesAsync();
producer = context.AllRegisteredProducers
.SingleOrDefault(p => p.Id == producer.Id);
Assert.NotNull(producer);
Assert.True(producer.Removed);
Assert.NotNull(producer.RemovedDate);
Assert.Equal(new DateTime(2016, 10, 1), producer.RemovedDate);
}
}
public async Task CreateRegisteredProducer_ProducerIsNotRemoved()
{
using (DatabaseWrapper database = new DatabaseWrapper())
{
var context = database.WeeeContext;
var organisation = Organisation.CreateSoleTrader("My trading name");
context.Organisations.Add(organisation);
await context.SaveChangesAsync();
var scheme = new Scheme(organisation.Id);
context.Schemes.Add(scheme);
await context.SaveChangesAsync();
var producer = new RegisteredProducer("ABC12345", 2017, scheme);
context.AllRegisteredProducers.Add(producer);
await context.SaveChangesAsync();
producer = context.RegisteredProducers
.SingleOrDefault(p => p.Id == producer.Id);
Assert.NotNull(producer);
Assert.False(producer.Removed);
Assert.Null(producer.RemovedDate);
}
}
public async Task <List <int> > HandleAsync(Request message)
{
Domain.Scheme.Scheme scheme = await dataAccess.FetchSchemeByOrganisationIdAsync(message.PcsId);
authorization.EnsureSchemeAccess(scheme.Id);
return(await dataAccess.GetDataReturnComplianceYearsForScheme(scheme.Id));
}
public async Task HandleAsync_Always_CreatesFileNameWithSchemeApprovalNumberComplianceYearAndCurrentTime()
{
// Arrange
Domain.Scheme.Scheme scheme = new Domain.Scheme.Scheme(A.Dummy <Organisation>());
scheme.UpdateScheme(
"Scheme name",
"WEE/AB1234CD/SCH",
A.Dummy <string>(),
A.Dummy <Domain.Obligation.ObligationType?>(),
A.Dummy <UKCompetentAuthority>());
IFetchSummaryCsvDataAccess dataAccess = A.Fake <IFetchSummaryCsvDataAccess>();
A.CallTo(() => dataAccess.FetchSchemeAsync(A <Guid> ._))
.Returns(scheme);
FetchSummaryCsvHandler handler = new FetchSummaryCsvHandler(
A.Dummy <IWeeeAuthorization>(),
A.Dummy <CsvWriterFactory>(),
dataAccess);
// Act
Requests.DataReturns.FetchSummaryCsv request = new Requests.DataReturns.FetchSummaryCsv(
A.Dummy <Guid>(),
2017);
SystemTime.Freeze(new DateTime(2016, 1, 2, 15, 22, 59), true);
FileInfo result = await handler.HandleAsync(request);
SystemTime.Unfreeze();
// Assert
Assert.NotNull(result);
Assert.Equal("WEE/AB1234CD/SCH_EEE_WEEE_data_2017_02012016_1522.csv", result.FileName);
}
public DataReturnVersionBuilderExtension(Scheme scheme, Quarter quarter,
Func <Scheme, Quarter, Func <Scheme, Quarter, IDataReturnVersionBuilderDataAccess>, IEeeValidator> eeeValidatorDelegate,
Func <Scheme, Quarter, IDataReturnVersionBuilderDataAccess> dataAccessDelegate, ISubmissionWindowClosed submissionWindowClosed, List <ErrorData> errorData)
: base(scheme, quarter, eeeValidatorDelegate, dataAccessDelegate, submissionWindowClosed)
{
Errors = errorData;
}
public EeeValidator(Scheme scheme, Quarter quarter,
Func <Scheme, Quarter, IDataReturnVersionBuilderDataAccess> dataAccessDelegate)
{
this.scheme = scheme;
this.quarter = quarter;
schemeQuarterDataAccess = dataAccessDelegate(scheme, quarter);
}
public EeeValidator(Scheme scheme, Quarter quarter,
Func<Scheme, Quarter, IDataReturnVersionBuilderDataAccess> dataAccessDelegate)
{
this.scheme = scheme;
this.quarter = quarter;
schemeQuarterDataAccess = dataAccessDelegate(scheme, quarter);
}
public void CheckSchemeAccess_ReturnsTrue_WhenUserHasRequiredClaims()
{
// Arrange
Guid organisationID = Guid.NewGuid();
Guid userId = Guid.NewGuid();
Guid schemeID = new Guid("5F3069F4-EDA3-43A3-BDD8-726028CDABB0");
Domain.Scheme.Scheme scheme = new Domain.Scheme.Scheme(organisationID);
typeof(Entity).GetProperty("Id").SetValue(scheme, schemeID); // <- sad but necessary
IUserContext userContext = A.Fake <IUserContext>();
WeeeContext weeeContext =
MakeFakeWeeeContext(
userContext,
userId,
new List <OrganisationUser> {
new OrganisationUser(userId, organisationID, UserStatus.Active)
},
new List <Domain.Scheme.Scheme> {
scheme
});
A.CallTo(() => userContext.UserId).Returns(userId);
WeeeAuthorization authorization = new WeeeAuthorization(weeeContext, userContext);
// Act
bool result = authorization.CheckSchemeAccess(schemeID);
// Assert
Assert.Equal(true, result);
}
public async Task Execute_GivenWeeeReceivedData_ReturnsPcsAatfDiscrepancyDataShouldBeCorrect()
{
using (DatabaseWrapper db = new DatabaseWrapper())
{
// Arrange
Organisation organisation = Organisation.CreateSoleTrader("Test Organisation");
Domain.UKCompetentAuthority authority = db.WeeeContext.UKCompetentAuthorities.Single(c => c.Abbreviation == UKCompetentAuthorityAbbreviationType.EA);
var year = 2019;
Quarter quarter = new Quarter(year, QuarterType.Q1);
Scheme scheme1 = new Scheme(organisation);
scheme1.UpdateScheme("Test Scheme 1", "WEE/AH7453NF/SCH", "WEE9462846", Domain.Obligation.ObligationType.B2B, 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.WeeeDeliveredAmount amount1 = new Domain.DataReturns.WeeeDeliveredAmount(
Domain.Obligation.ObligationType.B2B,
WeeeCategory.LargeHouseholdAppliances,
123.456m, new AatfDeliveryLocation("WEE/AA1111AA/ATF", string.Empty));
db.WeeeContext.DataReturns.Add(dataReturn1);
db.WeeeContext.DataReturnVersions.Add(version1);
version1.WeeeDeliveredReturnVersion.AddWeeeDeliveredAmount(amount1);
await db.WeeeContext.SaveChangesAsync();
dataReturn1.SetCurrentVersion(version1);
await db.WeeeContext.SaveChangesAsync();
var @return = CreateSubmittedReturn(db, organisation);
var aatf = new Aatf("aatfName", db.WeeeContext.UKCompetentAuthorities.First(), "WEE/AA1111AA/ATF", AatfStatus.Approved, organisation, AddressHelper.GetAatfAddress(db), AatfSize.Large, DateTime.Now, ObligatedWeeeIntegrationCommon.CreateDefaultContact(db.WeeeContext.Countries.First()), FacilityType.Aatf, (short)year, null, null);
var weeeReceived = new EA.Weee.Domain.AatfReturn.WeeeReceived(scheme1, aatf, @return);
var weeeReceivedAmounts = new List <WeeeReceivedAmount>()
{
new Domain.AatfReturn.WeeeReceivedAmount(weeeReceived, 1, 2, 10)
};
db.WeeeContext.Returns.Add(@return);
db.WeeeContext.ReturnAatfs.Add(new ReturnAatf(aatf, @return));
db.WeeeContext.WeeeReceived.Add(weeeReceived);
db.WeeeContext.WeeeReceivedAmount.AddRange(weeeReceivedAmounts);
await db.WeeeContext.SaveChangesAsync();
// Act
var results = await db.StoredProcedures.GetPcsAatfComparisonDataCsvData(year, null, string.Empty);
var record = results.First(x => x.AatfApprovalNumber == "WEE/AA1111AA/ATF" && x.ObligationType == "B2B");
//Assert
Assert.NotNull(record);
Assert.Equal("WEE/AA1111AA/ATF", record.AatfApprovalNumber);
Assert.Equal(123.456m, record.PcsTonnage);
Assert.Equal(10, record.AatfTonnage);
Assert.Equal(113.456m, record.DifferenceTonnage);
}
}
public EeeValidatorBuilder()
{
Year = 2016;
Quarter = QuarterType.Q1;
Scheme = A.Fake <Scheme>();
DataAccess = A.Fake <IDataReturnVersionBuilderDataAccess>();
}
public DataReturnVersionBuilderHelper()
{
Scheme = A.Dummy <Scheme>();
Quarter = A.Dummy <Quarter>();
EeeValidator = A.Fake <IEeeValidator>();
DataAccess = A.Fake <IDataReturnVersionBuilderDataAccess>();
SubmissionWindowClosed = A.Fake <ISubmissionWindowClosed>();
dataAccessDelegate = (x, y) => DataAccess;
eeeValidatorDelegate = (s, q, z) => EeeValidator;
}
public ReturnMapTests()
{
mapper = A.Fake <IMapper>();
organisationMapper = A.Fake <IMap <Organisation, OrganisationData> >();
statusMapper = A.Fake <IMap <AatfStatus, Core.AatfReturn.AatfStatus> >();
map = new ReturnMap(mapper, organisationMapper, statusMapper);
aatf = A.Fake <DomainAatf>();
scheme = A.Fake <DomainScheme>();
organisation = Organisation.CreatePartnership("trading name");
}
public async Task <SchemePublicInfo> HandleAsync(Requests.Scheme.GetSchemePublicInfo message)
{
Domain.Scheme.Scheme scheme = await dataAccess.FetchSchemeByOrganisationId(message.OrganisationId);
return(new SchemePublicInfo()
{
SchemeId = scheme.Id,
OrganisationId = scheme.OrganisationId,
Name = scheme.SchemeName,
ApprovalNo = scheme.ApprovalNumber,
StatusName = scheme.SchemeStatus.DisplayName
});
}
public async Task <FileInfo> HandleAsync(FetchIssuedChargesCsv message)
{
authorization.EnsureCanAccessInternalArea();
UKCompetentAuthority authority = await dataAccess.FetchCompetentAuthority(message.Authority);
IEnumerable <ProducerSubmission> results = await dataAccess.FetchInvoicedProducerSubmissionsAsync(authority, message.ComplianceYear, message.SchemeId);
CsvWriter <ProducerSubmission> csvWriter = csvWriterFactory.Create <ProducerSubmission>();
csvWriter.DefineColumn("Scheme name", ps => ps.RegisteredProducer.Scheme.SchemeName);
csvWriter.DefineColumn("Compliance year", ps => ps.RegisteredProducer.ComplianceYear);
csvWriter.DefineColumn("Submission date and time (GMT)", ps => ps.MemberUpload.SubmittedDate.Value.ToString("dd/MM/yyyy HH:mm:ss"));
csvWriter.DefineColumn("Producer name", ps => ps.OrganisationName);
csvWriter.DefineColumn("PRN", ps => ps.RegisteredProducer.ProducerRegistrationNumber);
csvWriter.DefineColumn("Charge value (GBP)", ps => ps.ChargeThisUpdate);
csvWriter.DefineColumn("Charge band", ps => ps.ChargeBandAmount.ChargeBand);
csvWriter.DefineColumn("Issued date", ps => ps.MemberUpload.InvoiceRun.IssuedDate.ToString("dd/MM/yyyy HH:mm:ss"));
csvWriter.DefineColumn(@"Reg. Off. or PPoB country", ps => ps.RegOfficeOrPBoBCountry);
csvWriter.DefineColumn(@"Includes annual charge", ps => ps.HasAnnualCharge);
string content = csvWriter.Write(results);
byte[] data = Encoding.UTF8.GetBytes(content);
string schemeApprovalNumber = string.Empty;
string fileName = string.Empty;
if (message.SchemeId.HasValue)
{
//get approval number for scheme to display in the filename.
Domain.Scheme.Scheme scheme = await dataAccess.FetchSchemeAsync(message.SchemeId);
schemeApprovalNumber = scheme.ApprovalNumber.Replace("/", string.Empty);
fileName = string.Format(
"{0}_{1}_issuedcharges_{2:ddMMyyyy_HHmm}.csv",
message.ComplianceYear,
schemeApprovalNumber,
SystemTime.UtcNow);
}
else
{
fileName = string.Format(
"{0}_issuedcharges_{1:ddMMyyyy_HHmm}.csv",
message.ComplianceYear,
SystemTime.UtcNow);
}
return(new FileInfo(fileName, data));
}
private RegisteredProducer CreateRegisteredProducer(Scheme scheme, int complianceYear, string registrationNumber, string organisationName)
{
var registeredProducer = new RegisteredProducer(registrationNumber, complianceYear, scheme);
var producerSubmission = A.Fake <ProducerSubmission>();
A.CallTo(() => producerSubmission.OrganisationName)
.Returns(organisationName);
A.CallTo(() => producerSubmission.RegisteredProducer)
.Returns(registeredProducer);
registeredProducer.SetCurrentSubmission(producerSubmission);
return(registeredProducer);
}
public DataReturnVersionFromXmlBuilderHelper(string schemeApprovalNumber)
{
DataReturnVersionBuilder = A.Fake <IDataReturnVersionBuilder>();
SchemeApprovalNumberMismatch = A.Fake <ISchemeApprovalNumberMismatch>();
Scheme scheme = new Scheme(new Guid("FE4056B3-F892-476E-A4AB-7C111AE1EF14"));
scheme.UpdateScheme(
"Test scheme",
schemeApprovalNumber,
"1B1S",
ObligationType.Both,
new Guid("C5D400BE-0CE7-43D7-BD7B-B7936967E500"));
A.CallTo(() => DataReturnVersionBuilder.Scheme).Returns(scheme);
}
public async Task <Scheme> FetchSchemeAsync(Guid schemeId)
{
Scheme scheme = await context.Schemes
.Where(s => s.Id == schemeId)
.SingleOrDefaultAsync();
if (scheme == null)
{
string errorMessage = string.Format(
"A scheme with ID \"{0}\" could not be found.",
schemeId);
throw new ArgumentException(errorMessage);
}
return(scheme);
}
public async Task Add_EntityShouldBeAdded()
{
using (var database = new DatabaseWrapper())
{
int originalSchemesCount = database.WeeeContext.Schemes.Count();
UpdateSchemeInformationDataAccess dataAccess = new UpdateSchemeInformationDataAccess(database.WeeeContext);
Organisation organisation = ObligatedWeeeIntegrationCommon.CreateOrganisation();
Scheme scheme = ObligatedWeeeIntegrationCommon.CreateScheme(organisation);
dataAccess.AddScheme(scheme);
await dataAccess.SaveAsync();
database.WeeeContext.Schemes.Where(p => Equals(scheme)).Should().NotBeNull();
int newSchemesCount = database.WeeeContext.Schemes.Count();
(newSchemesCount - originalSchemesCount).Should().Be(1);
}
}
public async Task <CSVFileData> HandleAsync(GetProducerEeeDataCsv request)
{
authorization.EnsureCanAccessInternalArea();
string obligationType = ConvertEnumToDatabaseString(request.ObligationType);
CsvWriter <ProducerEeeCsvData> csvWriter = CreateWriter(obligationType);
List <ProducerEeeCsvData> items = await dataAccess.GetItemsAsync(
request.ComplianceYear,
request.SchemeId,
obligationType);
string fileContent = csvWriter.Write(items);
string fileName;
if (request.SchemeId == null)
{
fileName = string.Format("{0}_{1}_producerEEE_{2:ddMMyyyy_HHmm}.csv",
request.ComplianceYear,
obligationType,
DateTime.UtcNow);
}
else
{
Domain.Scheme.Scheme scheme = await dataAccess.GetSchemeAsync(request.SchemeId.Value);
fileName = string.Format("{0}_{1}_{2}_producerEEE_{3:ddMMyyyy_HHmm}.csv",
request.ComplianceYear,
scheme.ApprovalNumber.Replace("/", string.Empty),
obligationType,
DateTime.UtcNow);
}
return(new CSVFileData
{
FileContent = fileContent,
FileName = fileName
});
}
public DataReturnVersionBuilder(
Scheme scheme,
Quarter quarter,
Func <Scheme, Quarter, Func <Scheme, Quarter, IDataReturnVersionBuilderDataAccess>, IEeeValidator> eeeValidatorDelegate,
Func <Scheme, Quarter, IDataReturnVersionBuilderDataAccess> dataAccessDelegate,
ISubmissionWindowClosed submissionWindowClosed)
{
Guard.ArgumentNotNull(() => scheme, scheme);
Guard.ArgumentNotNull(() => quarter, quarter);
Scheme = scheme;
Quarter = quarter;
eeeValidator = eeeValidatorDelegate(scheme, quarter, dataAccessDelegate);
schemeQuarterDataAccess = dataAccessDelegate(scheme, quarter);
this.submissionWindowClosed = submissionWindowClosed;
Errors = new List <ErrorData>();
weeeCollectedAmounts = new List <WeeeCollectedAmount>();
weeeDeliveredAmounts = new List <WeeeDeliveredAmount>();
eeeOutputAmounts = new List <EeeOutputAmount>();
}
public void ContactAddedToExistingScheme_SchemeUpdateIsAudited_ContactCreateIsAudited()
{
using (DatabaseWrapper database = new DatabaseWrapper())
{
var context = database.WeeeContext;
var organisation = Organisation.CreateSoleTrader("test name");
var scheme = new Scheme(organisation);
organisation = context.Organisations.Add(organisation);
scheme = context.Schemes.Add(scheme);
context.SaveChanges(); // This will reset the change tracker
scheme.AddOrUpdateMainContactPerson(new Contact("first", "last", "position"));
var schemeChanges = context.ChangeTracker.Entries <Scheme>();
var contactChanges = context.ChangeTracker.Entries <Contact>();
Assert.Equal(EntityState.Added, contactChanges.Single().State);
Assert.Equal(EntityState.Modified, schemeChanges.Single().State);
}
}
public async Task FetchOrganisations_OrganisationWithRejectedPcs_OneAatf_OrganisationReturned()
{
var dbContextHelper = new DbContextHelper();
var organisationId = Guid.NewGuid();
var organisation = A.Dummy <Domain.Organisation.Organisation>();
A.CallTo(() => organisation.Id).Returns(organisationId);
A.CallTo(() => organisation.OrganisationStatus).Returns(Domain.Organisation.OrganisationStatus.Complete);
var organisations = new List <Domain.Organisation.Organisation>()
{
organisation
};
var aatfs = new List <Aatf>()
{
new Aatf("one", A.Dummy <UKCompetentAuthority>(), "1234", AatfStatus.Approved, organisation, A.Dummy <AatfAddress>(), AatfSize.Large, DateTime.Now, A.Dummy <AatfContact>(), FacilityType.Aatf, 2019, A.Dummy <LocalArea>(), A.Dummy <PanArea>())
};
var scheme = new Domain.Scheme.Scheme(organisation);
scheme.SetStatus(Domain.Scheme.SchemeStatus.Rejected);
var schemes = new List <Domain.Scheme.Scheme>()
{
scheme
};
A.CallTo(() => context.Organisations).Returns(dbContextHelper.GetAsyncEnabledDbSet(organisations));
A.CallTo(() => context.Aatfs).Returns(dbContextHelper.GetAsyncEnabledDbSet(aatfs));
A.CallTo(() => context.Schemes).Returns(dbContextHelper.GetAsyncEnabledDbSet(schemes));
var dataAccess = new FetchOrganisationSearchResultsForCacheDataAccess(context, new AddressMap());
var results = await dataAccess.FetchCompleteOrganisations();
Assert.NotEmpty(results);
}
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();
}
public void AddressAddedToExistingScheme_SchemeUpdateIsAudited_AddressCreateIsAudited()
{
using (DatabaseWrapper database = new DatabaseWrapper())
{
var context = database.WeeeContext;
var organisation = Organisation.CreateSoleTrader("test name");
var scheme = new Scheme(organisation);
organisation = context.Organisations.Add(organisation);
scheme = context.Schemes.Add(scheme);
context.SaveChanges(); // This will reset the change tracker
scheme.AddOrUpdateAddress(ValidAddress());
var schemeChanges = context.ChangeTracker.Entries <Scheme>();
var addressChanges = context.ChangeTracker.Entries <Address>();
Assert.Equal(EntityState.Added, addressChanges.Single().State);
Assert.Equal(EntityState.Modified, schemeChanges.Single().State);
}
}
public async Task HandleAsync_GivenSchemeListAndOperator_SchemeDataListShouldBeOrderedBySchemeName()
{
var organisationData = A.Fake <Core.Organisations.OrganisationData>();
Organisation organisation = Organisation.CreateSoleTrader("Test Organisation");
Scheme scheme1 = new Scheme(organisation);
Scheme scheme2 = new Scheme(organisation);
var @return = A.Dummy <Return>();
var returnScheme = new List <ReturnScheme>()
{
new ReturnScheme(scheme1, @return),
new ReturnScheme(scheme2, @return)
};
schemeData1 = A.Fake <SchemeData>();
schemeData1.SchemeName = "Scheme D";
schemeData1.SchemeStatus = Core.Shared.SchemeStatus.Approved;
A.CallTo(() => mapper.Map <Scheme, SchemeData>(scheme1)).Returns(schemeData1);
schemeData2 = A.Fake <SchemeData>();
schemeData2.SchemeName = "Scheme A";
schemeData2.SchemeStatus = Core.Shared.SchemeStatus.Approved;
A.CallTo(() => mapper.Map <Scheme, SchemeData>(scheme2)).Returns(schemeData2);
var schemeList = new List <SchemeData> {
schemeData1, schemeData2
};
A.CallTo(() => mapper.Map <Organisation, OrganisationData>(A <Organisation> ._)).Returns(organisationData);
A.CallTo(() => returnSchemeDataAccess.GetSelectedSchemesByReturnId(A <Guid> ._)).Returns(returnScheme);
var result = await handler.HandleAsync(A.Dummy <GetReturnScheme>());
Assert.Collection(
result.SchemeDataItems,
(element1) => Assert.Equal("Scheme A", element1.SchemeName),
(element2) => Assert.Equal("Scheme D", element2.SchemeName));
}
public async Task CanCreateReturnScheme()
{
using (var database = new DatabaseWrapper())
{
var context = database.WeeeContext;
var name = "Test Name" + Guid.NewGuid();
var tradingName = "Test Trading Name" + Guid.NewGuid();
const string crn = "ABC12345";
var organisation = Organisation.Organisation.CreateRegisteredCompany(name, crn, tradingName);
context.Organisations.Add(organisation);
await context.SaveChangesAsync();
var scheme = new Scheme(organisation.Id);
context.Schemes.Add(scheme);
var quarter = new Quarter(2019, QuarterType.Q1);
var @return = new Return(organisation, quarter, database.Model.AspNetUsers.First().Id, FacilityType.Aatf);
context.Returns.Add(@return);
await context.SaveChangesAsync();
var dataAccess = new ReturnSchemeDataAccess(database.WeeeContext);
var returnScheme = new ReturnScheme(scheme, @return);
await dataAccess.Submit(new List <ReturnScheme> {
returnScheme
});
var returnSchemeReturned = context.ReturnScheme.First(o => o.Id == returnScheme.Id);
returnSchemeReturned.Should().NotBeNull();
returnSchemeReturned.ReturnId.Should().Be(@return.Id);
returnSchemeReturned.SchemeId.Should().Be(scheme.Id);
}
}
public async Task <FileInfo> HandleAsync(Requests.DataReturns.FetchSummaryCsv message)
{
authorization.EnsureInternalOrOrganisationAccess(message.OrganisationId);
Domain.Scheme.Scheme scheme = await dataAccess.FetchSchemeAsync(message.OrganisationId);
List <DataReturnSummaryCsvData> results = await dataAccess.FetchResultsAsync(
scheme.Id,
message.ComplianceYear);
CsvWriter <DataReturnSummaryCsvData> csvWriter = CreateWriter();
string content = csvWriter.Write(results);
byte[] data = Encoding.UTF8.GetBytes(content);
string fileName = string.Format("{0}_EEE_WEEE_data_{1}_{2:ddMMyyyy_HHmm}.csv",
scheme.ApprovalNumber,
message.ComplianceYear,
SystemTime.Now);
return(new FileInfo(fileName, data));
}
public async Task FetchOrganisations_OrganisationWithRejectedPcs_NoAatfs_OrganisationNotReturned()
{
var dbContextHelper = new DbContextHelper();
var organisationId = Guid.NewGuid();
var organisation = A.Dummy <Domain.Organisation.Organisation>();
A.CallTo(() => organisation.Id).Returns(organisationId);
A.CallTo(() => organisation.OrganisationStatus).Returns(Domain.Organisation.OrganisationStatus.Complete);
var organisations = new List <Domain.Organisation.Organisation>()
{
organisation
};
var aatfs = new List <Aatf>();
var scheme = new Domain.Scheme.Scheme(organisation);
scheme.SetStatus(Domain.Scheme.SchemeStatus.Rejected);
var schemes = new List <Domain.Scheme.Scheme>()
{
scheme
};
A.CallTo(() => context.Organisations).Returns(dbContextHelper.GetAsyncEnabledDbSet(organisations));
A.CallTo(() => context.Aatfs).Returns(dbContextHelper.GetAsyncEnabledDbSet(aatfs));
A.CallTo(() => context.Schemes).Returns(dbContextHelper.GetAsyncEnabledDbSet(schemes));
var dataAccess = new FetchOrganisationSearchResultsForCacheDataAccess(context, new AddressMap());
var results = await dataAccess.FetchCompleteOrganisations();
Assert.Empty(results);
}
private static async Task CreateWeeeReceivedAmounts(
ObligatedReceivedDataAccess dataAccess,
ReturnSchemeDataAccess returnSchemeDataAccess,
Return @return,
Aatf aatf,
Scheme scheme)
{
var returnScheme = new ReturnScheme(scheme, @return);
var weeeReceived = new WeeeReceived(scheme, aatf, @return);
var weeeReceivedAmount = new List <WeeeReceivedAmount>();
foreach (var category in Enum.GetValues(typeof(WeeeCategory)).Cast <WeeeCategory>())
{
weeeReceivedAmount.Add(new WeeeReceivedAmount(weeeReceived, (int)category, (int)category, (int)category + 1));
}
await returnSchemeDataAccess.Submit(new List <ReturnScheme> {
returnScheme
});
await dataAccess.Submit(weeeReceivedAmount);
}
public DataReturnVersionBuilderDataAccess(Scheme scheme, Quarter quarter, WeeeContext context)
{
this.context = context;
this.scheme = scheme;
this.quarter = quarter;
}
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 == "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", 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,
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", 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,
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);
}
}
public void CheckSchemeAccess_ReturnsTrue_WhenUserHasRequiredClaims()
{
// Arrange
Guid organisationID = Guid.NewGuid();
Guid userId = Guid.NewGuid();
Guid schemeID = new Guid("5F3069F4-EDA3-43A3-BDD8-726028CDABB0");
Domain.Scheme.Scheme scheme = new Domain.Scheme.Scheme(organisationID);
typeof(Entity).GetProperty("Id").SetValue(scheme, schemeID); // <- sad but necessary
IUserContext userContext = A.Fake<IUserContext>();
WeeeContext weeeContext =
MakeFakeWeeeContext(
userContext,
userId,
new List<OrganisationUser> { new OrganisationUser(userId, organisationID, UserStatus.Active) },
new List<Domain.Scheme.Scheme> { scheme });
A.CallTo(() => userContext.UserId).Returns(userId);
WeeeAuthorization authorization = new WeeeAuthorization(weeeContext, userContext);
// Act
bool result = authorization.CheckSchemeAccess(schemeID);
// Assert
Assert.Equal(true, result);
}
public SchemeFieldException(Scheme scheme, Exception exception)
{
Scheme = scheme;
Exception = exception;
}
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);
}
}
public DataReturnVersionBuilderHelper()
{
Scheme = A.Dummy<Scheme>();
Quarter = A.Dummy<Quarter>();
EeeValidator = A.Fake<IEeeValidator>();
DataAccess = A.Fake<IDataReturnVersionBuilderDataAccess>();
SubmissionWindowClosed = A.Fake<ISubmissionWindowClosed>();
dataAccessDelegate = (x, y) => DataAccess;
eeeValidatorDelegate = (s, q, z) => EeeValidator;
}
public EeeValidatorBuilder()
{
Year = 2016;
Quarter = QuarterType.Q1;
Scheme = A.Fake<Scheme>();
DataAccess = A.Fake<IDataReturnVersionBuilderDataAccess>();
}
public DataReturnVersionFromXmlBuilderHelper(string schemeApprovalNumber)
{
DataReturnVersionBuilder = A.Fake<IDataReturnVersionBuilder>();
SchemeApprovalNumberMismatch = A.Fake<ISchemeApprovalNumberMismatch>();
Scheme scheme = new Scheme(new Guid("FE4056B3-F892-476E-A4AB-7C111AE1EF14"));
scheme.UpdateScheme(
"Test scheme",
schemeApprovalNumber,
"1B1S",
ObligationType.Both,
new Guid("C5D400BE-0CE7-43D7-BD7B-B7936967E500"));
A.CallTo(() => DataReturnVersionBuilder.Scheme).Returns(scheme);
}
public DataReturnVersionBuilderExtension(Scheme scheme, Quarter quarter,
Func<Scheme, Quarter, Func<Scheme, Quarter, IDataReturnVersionBuilderDataAccess>, IEeeValidator> eeeValidatorDelegate,
Func<Scheme, Quarter, IDataReturnVersionBuilderDataAccess> dataAccessDelegate, ISubmissionWindowClosed submissionWindowClosed, List<ErrorData> errorData)
: base(scheme, quarter, eeeValidatorDelegate, dataAccessDelegate, submissionWindowClosed)
{
Errors = errorData;
}
public async Task Execute_WithSchemeFilter_ReturnsResultsForSelectedSchemeOnly()
{
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 == "EA");
Domain.Lookup.ChargeBandAmount chargeBandAmount = wrapper.WeeeContext.ChargeBandAmounts.First();
Quarter quarter = new Quarter(2099, QuarterType.Q1);
wrapper.WeeeContext.Organisations.Add(organisation);
await wrapper.WeeeContext.SaveChangesAsync();
// Arrange - Scheme 1
Domain.Scheme.Scheme scheme1 = new Domain.Scheme.Scheme(organisation);
scheme1.UpdateScheme("Test Scheme 1", "WEE/AH7453NF/SCH", "WEE9462846", ObligationType.B2C, authority);
scheme1.SetStatus(Domain.Scheme.SchemeStatus.Approved);
Domain.Producer.RegisteredProducer registeredProducer1 = new Domain.Producer.RegisteredProducer("WEE/AG48365JN", 2099, scheme1);
Domain.Scheme.MemberUpload memberUpload1 = new Domain.Scheme.MemberUpload(
organisation.Id,
"data",
new List<Domain.Scheme.MemberUploadError>(),
0,
2099,
scheme1,
"file name");
Domain.Producer.ProducerSubmission submission1 = new Domain.Producer.ProducerSubmission(registeredProducer1, memberUpload1,
new Domain.Producer.ProducerBusiness(),
new Domain.Producer.AuthorisedRepresentative("Foo"),
new DateTime(2016, 1, 1),
0,
true,
null,
"Trading Name 2",
Domain.Producer.Classfication.EEEPlacedOnMarketBandType.Both,
Domain.Producer.Classfication.SellingTechniqueType.Both,
Domain.Obligation.ObligationType.B2C,
Domain.Producer.Classfication.AnnualTurnOverBandType.Lessthanorequaltoonemillionpounds,
new List<Domain.Producer.BrandName>(),
new List<Domain.Producer.SICCode>(),
chargeBandAmount,
0);
memberUpload1.ProducerSubmissions.Add(submission1);
wrapper.WeeeContext.MemberUploads.Add(memberUpload1);
await wrapper.WeeeContext.SaveChangesAsync();
registeredProducer1.SetCurrentSubmission(submission1);
await wrapper.WeeeContext.SaveChangesAsync();
Domain.DataReturns.DataReturn dataReturn1 = new Domain.DataReturns.DataReturn(scheme1, quarter);
Domain.DataReturns.DataReturnVersion version1 = new Domain.DataReturns.DataReturnVersion(dataReturn1);
Domain.DataReturns.EeeOutputAmount amount1 = new Domain.DataReturns.EeeOutputAmount(
ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
123.456m,
registeredProducer1);
version1.EeeOutputReturnVersion.AddEeeOutputAmount(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", ObligationType.B2C, authority);
scheme2.SetStatus(Domain.Scheme.SchemeStatus.Approved);
Domain.Producer.RegisteredProducer registeredProducer2 = new Domain.Producer.RegisteredProducer("WEE/HT7483HD", 2099, scheme2);
Domain.Scheme.MemberUpload memberUpload2 = new Domain.Scheme.MemberUpload(
organisation.Id,
"data",
new List<Domain.Scheme.MemberUploadError>(),
0,
2099,
scheme2,
"file name");
Domain.Producer.ProducerSubmission submission2 = new Domain.Producer.ProducerSubmission(registeredProducer2, memberUpload2,
new Domain.Producer.ProducerBusiness(),
new Domain.Producer.AuthorisedRepresentative("Foo"),
new DateTime(2016, 1, 1),
0,
true,
null,
"Trading Name 1",
Domain.Producer.Classfication.EEEPlacedOnMarketBandType.Both,
Domain.Producer.Classfication.SellingTechniqueType.Both,
Domain.Obligation.ObligationType.B2C,
Domain.Producer.Classfication.AnnualTurnOverBandType.Lessthanorequaltoonemillionpounds,
new List<Domain.Producer.BrandName>(),
new List<Domain.Producer.SICCode>(),
chargeBandAmount,
0);
memberUpload2.ProducerSubmissions.Add(submission2);
wrapper.WeeeContext.MemberUploads.Add(memberUpload2);
await wrapper.WeeeContext.SaveChangesAsync();
registeredProducer2.SetCurrentSubmission(submission2);
await wrapper.WeeeContext.SaveChangesAsync();
Domain.DataReturns.DataReturn dataReturn2 = new Domain.DataReturns.DataReturn(scheme2, quarter);
Domain.DataReturns.DataReturnVersion version2 = new Domain.DataReturns.DataReturnVersion(dataReturn2);
Domain.DataReturns.EeeOutputAmount amount2 = new Domain.DataReturns.EeeOutputAmount(
ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
123.456m,
registeredProducer2);
version2.EeeOutputReturnVersion.AddEeeOutputAmount(amount2);
wrapper.WeeeContext.DataReturnVersions.Add(version2);
await wrapper.WeeeContext.SaveChangesAsync();
dataReturn2.SetCurrentVersion(version2);
await wrapper.WeeeContext.SaveChangesAsync();
// Act
List<ProducerEeeCsvData> results = await wrapper.WeeeContext.StoredProcedures.SpgProducerEeeCsvData(
2099,
scheme1.Id,
"B2C");
// Assert
Assert.NotNull(results);
Assert.Equal(1, results.Count);
Assert.NotNull(results[0]);
Assert.Equal("Test Scheme 1", results[0].SchemeName);
}
}
