public async Task <List <Guid> > Submit(List <ReturnScheme> schemes)
{
context.ReturnScheme.AddRange(schemes);
await context.SaveChangesAsync();
return(schemes.Select(s => s.Id).ToList());
}
public async Task <Guid> Add <TEntity>(TEntity entity) where TEntity : Entity
{
context.Set <TEntity>().Add(entity);
await context.SaveChangesAsync();
return(entity.Id);
}
public async Task SetFixedDate(DateTime date)
{
var systemData = await systemDataDataAccess.Get();
systemData.UpdateFixedCurrentDate(date);
await context.SaveChangesAsync();
}
public async void AddCompetentAuthorityUserHandler_ReturnsCompetentAuthorityId()
{
AddCompetentAuthorityUser message = new AddCompetentAuthorityUser(InternalUserId.ToString());
var id = await handler.HandleAsync(message);
A.CallTo(() => context.SaveChangesAsync()).MustHaveHappened();
Assert.NotNull(id);
}
public Task Submit(IEnumerable <NonObligatedWeee> nonObligated)
{
foreach (var nonObligatedWeee in nonObligated)
{
context.NonObligatedWeee.Add(nonObligatedWeee);
}
return(context.SaveChangesAsync());
}
public void Submit_GivenReusedSiteData_SaveChangesAsyncShouldBeCalled()
{
var site = new WeeeReusedSite();
dataAccess.Submit(site);
A.CallTo(() => context.WeeeReusedSite.Add(site)).MustHaveHappened(Repeated.Exactly.Once)
.Then(A.CallTo(() => context.SaveChangesAsync()).MustHaveHappened(Repeated.Exactly.Once));
}
public async Task Submit_GivenSchemeAddedToContext_ChangesShouldBeSaved()
{
var items = A.Fake <List <ReturnScheme> >();
await dataAccess.Submit(items);
A.CallTo(() => context.ReturnScheme.AddRange(items)).MustHaveHappened().Then(
A.CallTo(() => context.SaveChangesAsync()).MustHaveHappened(Repeated.Exactly.Once));
}
public async Task <Guid> HandleAsync(CopyReturn message)
{
authorization.EnsureCanAccessExternalArea();
var returnCopy = await context.Returns.Include(r => r.Organisation).FirstOrDefaultAsync(r => r.Id == message.ReturnId);
if (returnCopy == null)
{
throw new ArgumentException($"No return was found with id {message.ReturnId}.");
}
authorization.EnsureOrganisationAccess(returnCopy.Organisation.Id);
using (var transaction = context.Database.BeginTransaction())
{
try
{
await CopyReturnReportsOn(message, returnCopy);
await CopyReturnSchemes(message, returnCopy);
await CopyReturnNonObligated(message, returnCopy);
CopyReturnReceived(message, returnCopy);
CopyReturnSentOn(message, returnCopy);
CopyReturnReused(message, returnCopy);
CopyReturn(message, returnCopy);
await context.SaveChangesAsync();
await RemoveAatfsWithInvalidApprovalDate(returnCopy);
await context.SaveChangesAsync();
await RemoveAnyDuplicateNonObligatedAndSave(returnCopy);
transaction.Commit();
return(@returnCopy.Id);
}
catch
{
transaction.Rollback();
throw;
}
finally
{
transaction.Dispose();
}
}
}
public void Submit_GivenAmounts_AddRangeAndSaveChangesShouldBeCalled()
{
var list = new List <WeeeReceivedAmount>();
A.CallTo(() => context.Set <WeeeReceivedAmount>()).Returns(dbHelper.GetAsyncEnabledDbSet(list));
dataAccess.Submit(list);
A.CallTo(() => context.Set <WeeeReceivedAmount>().AddRange(A <IEnumerable <WeeeReceivedAmount> > .That.Matches(c => c.Equals(list)))).MustHaveHappened(Repeated.Exactly.Once).Then(
A.CallTo(() => context.SaveChangesAsync()).MustHaveHappened(Repeated.Exactly.Once));
}
public async Task HandleAsync_GivenReturn_StatusShouldBeUpdated(bool nilReturn)
{
var message = new SubmitReturn(Guid.NewGuid(), nilReturn);
var @return = A.Fake <Return>();
var userId = Guid.NewGuid();
A.CallTo(() => @return.ReturnStatus).Returns(Domain.AatfReturn.ReturnStatus.Created);
A.CallTo(() => genericDataAccess.GetById <Return>(message.ReturnId)).Returns(@return);
A.CallTo(() => userContext.UserId).Returns(userId);
await handler.HandleAsync(message);
A.CallTo(() => @return.UpdateSubmitted(userId.ToString(), nilReturn)).MustHaveHappened(Repeated.Exactly.Once)
.Then(A.CallTo(() => weeeContext.SaveChangesAsync()).MustHaveHappened(Repeated.Exactly.Once));
}
public async Task <Guid> HandleAsync(MemberUploadSubmission message)
{
authorization.EnsureOrganisationAccess(message.OrganisationId);
var memberUpload = await context.MemberUploads.SingleOrDefaultAsync(m => m.Id == message.MemberUploadId);
if (memberUpload == null)
{
throw new ArgumentNullException(string.Format("Could not find a MemberUpload with id {0}", message.MemberUploadId));
}
if (memberUpload.OrganisationId != message.OrganisationId)
{
throw new ArgumentException(string.Format("Member upload {0} is not owned by PCS {1}", message.MemberUploadId, message.OrganisationId));
}
if (!memberUpload.IsSubmitted)
{
User submittingUser = await domainUserContext.GetCurrentUserAsync();
memberUpload.Submit(submittingUser);
await context.SaveChangesAsync();
}
return(memberUpload.Id);
}
public async Task <bool> HandleAsync(RemoveWeeeSentOn message)
{
authorization.EnsureCanAccessExternalArea();
var weeeSentOn = await genericDataAccess.GetById <WeeeSentOn>(message.WeeeSentOnId);
if (weeeSentOn == null)
{
return(false);
}
var weeeSentOnAmount = await obligatedWeeeDataAccess.FetchObligatedWeeeSentOnForReturn(message.WeeeSentOnId);
genericDataAccess.Remove(weeeSentOn.SiteAddress);
genericDataAccess.Remove(weeeSentOn.OperatorAddress);
genericDataAccess.Remove(weeeSentOn);
genericDataAccess.RemoveMany(weeeSentOnAmount);
await context.SaveChangesAsync();
return(true);
}
public async Task <bool> HandleAsync(SubmitReturn message)
{
authorization.EnsureCanAccessExternalArea();
var @return = await genericDataAccess.GetById <Return>(message.ReturnId);
if (@return == null)
{
throw new ArgumentException($"No return was found with id {message.ReturnId}.");
}
if (@return.ReturnStatus == ReturnStatus.Submitted)
{
return(true);
}
authorization.EnsureOrganisationAccess(@return.Organisation.Id);
@return.UpdateSubmitted(userContext.UserId.ToString(), message.NilReturn);
var aatfs = await fetchAatfDataAccess.FetchAatfByReturnQuarterWindow(@return);
var returnAatfs = aatfs.Select(a => new ReturnAatf(a, @return));
await genericDataAccess.AddMany <ReturnAatf>(returnAatfs);
await weeeContext.SaveChangesAsync();
return(true);
}
public async Task <Guid> HandleAsync(AddContactPerson message)
{
authorization.EnsureOrganisationAccess(message.OrganisationId);
var contactPerson = ValueObjectInitializer.CreateContact(message.ContactPerson);
Guid id;
if (message.ContactId.HasValue)
{
var contact = await dataAccess.GetById <Contact>(message.ContactId.Value);
contact.Overwrite(contactPerson);
id = contact.Id;
}
else
{
id = await dataAccess.Add <Contact>(contactPerson);
}
await db.SaveChangesAsync();
return(id);
}
public async Task <int> UpdateUserRoleAndStatus(CompetentAuthorityUser user, Role role, UserStatus status)
{
user.UpdateUserStatus(status.ToDomainEnumeration <Domain.User.UserStatus>());
user.UpdateRole(role);
return(await context.SaveChangesAsync());
}
public async Task <Guid> Submit(Return aatfReturn)
{
context.Returns.Add(aatfReturn);
await context.SaveChangesAsync();
return(aatfReturn.Id);
}
public async Task <Guid> HandleAsync(CreatePartnershipRequest message)
{
authorization.EnsureCanAccessExternalArea();
var organisation = Organisation.CreatePartnership(message.TradingName);
db.Organisations.Add(organisation);
await db.SaveChangesAsync();
var organisationUser = new OrganisationUser(userContext.UserId, organisation.Id, UserStatus.Active);
db.OrganisationUsers.Add(organisationUser);
await db.SaveChangesAsync();
return(organisation.Id);
}
public Task Submit(IEnumerable <WeeeReusedAmount> aatfWeeeReusedAmounts)
{
foreach (var aatfWeeeReused in aatfWeeeReusedAmounts)
{
context.WeeeReusedAmount.Add(aatfWeeeReused);
}
return(context.SaveChangesAsync());
}
private static async Task <Scheme> CreateScheme(WeeeContext context, Organisation organisation)
{
var scheme = ObligatedWeeeIntegrationCommon.CreateScheme(organisation);
context.Schemes.Add(scheme);
await context.SaveChangesAsync();
return(scheme);
}
public void UpdateDetails_GivenNewData_SaveChangesAsyncShouldBeCalled()
{
var oldDetails = A.Fake <Aatf>();
var newDetails = fixture.Create <Aatf>();
dataAccess.UpdateDetails(oldDetails, newDetails);
A.CallTo(() => oldDetails.UpdateDetails(
newDetails.Name,
newDetails.CompetentAuthority,
newDetails.ApprovalNumber,
newDetails.AatfStatus,
newDetails.Organisation,
newDetails.Size,
newDetails.ApprovalDate,
newDetails.LocalArea,
newDetails.PanArea)).MustHaveHappenedOnceExactly()
.Then(A.CallTo(() => context.SaveChangesAsync()).MustHaveHappenedOnceExactly());
}
public async Task <Guid> HandleAsync(CreateRegisteredCompanyRequest message)
{
authorization.EnsureCanAccessExternalArea();
var organisation = Organisation.CreateRegisteredCompany(message.BusinessName,
message.CompanyRegistrationNumber, message.TradingName);
db.Organisations.Add(organisation);
await db.SaveChangesAsync();
var organisationUser = new OrganisationUser(userContext.UserId, organisation.Id, UserStatus.Active);
db.OrganisationUsers.Add(organisationUser);
await db.SaveChangesAsync();
return(organisation.Id);
}
public async void JoinOrganisation_OrganisationUserExistsWithNonRejectedStatus_ReturnsFailure_AndDoesNotSaveAnyChanges(Core.Shared.UserStatus userStatus)
{
var organisationId = Guid.NewGuid();
var userId = Guid.NewGuid();
A.CallTo(() => context.OrganisationUsers)
.Returns(contextHelper.GetAsyncEnabledDbSet(new List <OrganisationUser>
{
ValidOrganisationUser(userId, organisationId, userStatus)
}));
var result =
await JoinOrganisationDataAccess()
.JoinOrganisation(new OrganisationUser(userId, organisationId, UserStatus.Pending));
Assert.False((result).Successful);
A.CallTo(() => context.SaveChangesAsync())
.MustNotHaveHappened();
}
private static async Task <Return> CreateReturn(WeeeContext context, DatabaseWrapper database, Organisation organisation)
{
var @return = ObligatedWeeeIntegrationCommon.CreateReturn(organisation, database.Model.AspNetUsers.First().Id);
context.Organisations.Add(organisation);
context.Returns.Add(@return);
await context.SaveChangesAsync();
return(@return);
}
public async Task InsertNonObligatedWeee(Guid returnId, IEnumerable <NonObligatedWeee> nonObligatedWeees)
{
var allAssociatedWithReturn = await FetchNonObligatedWeeeForReturn(returnId);
foreach (var noWeee in nonObligatedWeees)
{
var group = allAssociatedWithReturn.Where(e => e.Dcf == noWeee.Dcf && e.CategoryId == noWeee.CategoryId);
if (group.Count() == 0)
{
context.NonObligatedWeee.Add(noWeee);
}
else
{
group.First().UpdateTonnage(noWeee.Tonnage);
context.NonObligatedWeee.RemoveRange(group.Skip(1)); // Remove any additional ones
}
}
await context.SaveChangesAsync();
return;
}
public async void ProcessXmlfile_ParsesXMLFile_SavesValidProducers()
{
IEnumerable <ProducerSubmission> generatedProducers = new[] { TestProducer("ForestMoonOfEndor") };
A.CallTo(() => generator.GenerateProducers(Message, A <MemberUpload> .Ignored, A <Dictionary <string, ProducerCharge> > .Ignored))
.Returns(Task.FromResult(generatedProducers));
SetupSchemeTypeComplianceYear();
await handler.HandleAsync(Message);
A.CallTo(() => producerSubmissionDataAccess.AddRange(generatedProducers)).MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => context.SaveChangesAsync()).MustHaveHappened();
}
public async Task SaveAsync_Always_CallsSaveOnContext()
{
// Arrange
WeeeContext context = A.Fake <WeeeContext>();
OrganisationDetailsDataAccess dataAccess = new OrganisationDetailsDataAccess(context);
// Act
await dataAccess.SaveAsync();
// Assert
A.CallTo(() => context.SaveChangesAsync())
.MustHaveHappened(Repeated.Exactly.Once);
}
public async void SchemeDoesExist_SetsSchemeStatus_AndSavesChanges(SchemeStatus status)
{
var scheme = new Scheme(Guid.NewGuid());
A.CallTo(() => context.Schemes)
.Returns(dbContextHelper.GetAsyncEnabledDbSet(new List <Scheme>
{
scheme
}));
await SetSchemeStatusHandler().HandleAsync(new SetSchemeStatus(scheme.Id, status));
Assert.Equal(status.ToDomainEnumeration <Domain.Scheme.SchemeStatus>(), context.Schemes.Single().SchemeStatus);
A.CallTo(() => context.SaveChangesAsync()).MustHaveHappened(Repeated.Exactly.Once);
}
private async Task <List <WeeeSentOnAmount> > AppendWeeeSentOnAmountToWeeeSentOn(WeeeContext context, WeeeSentOn weeeSentOn)
{
var weeeSentOnAmountList = new List <WeeeSentOnAmount>();
foreach (var category in Enum.GetValues(typeof(WeeeCategory)).Cast <WeeeCategory>())
{
weeeSentOnAmountList.Add(new WeeeSentOnAmount(weeeSentOn, (int)category, (decimal?)category, (decimal?)category + 1));
}
context.WeeeSentOnAmount.AddRange(weeeSentOnAmountList);
await context.SaveChangesAsync();
return(weeeSentOnAmountList);
}
public async Task <Guid> HandleAsync(AddAddressToOrganisation message)
{
authorization.EnsureOrganisationAccess(message.OrganisationId);
var addresstype = ValueObjectInitializer.GetAddressType(message.TypeOfAddress);
if (await db.Organisations.FirstOrDefaultAsync(o => o.Id == message.OrganisationId) == null)
{
throw new ArgumentException(string.Format("Could not find an organisation with id {0}",
message.OrganisationId));
}
var organisation = await db.Organisations.SingleAsync(o => o.Id == message.OrganisationId);
if (await db.Countries.FirstOrDefaultAsync(c => c.Id == message.Address.CountryId) == null)
{
throw new ArgumentException(string.Format("Could not find country with id {0}",
message.Address.CountryId));
}
var country = await db.Countries.SingleAsync(c => c.Id == message.Address.CountryId);
message.Address.CountryName = country.Name;
var address = ValueObjectInitializer.CreateAddress(message.Address, country);
if (addresstype.Equals(AddressType.SchemeAddress))
{
if (message.AddressId.HasValue)
{
var findAddress = await db.Addresses.SingleAsync(a => a.Id == message.AddressId.Value);
findAddress.Overwrite(address);
address = findAddress;
}
else
{
db.Addresses.Add(address);
}
}
else
{
organisation.AddOrUpdateAddress(addresstype, address);
}
await db.SaveChangesAsync();
return(GetAddressId(addresstype, organisation, address));
}
public async Task <Guid> HandleAsync(SetSchemeStatus message)
{
authorization.EnsureCanAccessInternalArea();
var scheme = await context.Schemes.SingleOrDefaultAsync(s => s.Id == message.PcsId);
if (scheme != null)
{
scheme.SetStatus(message.Status.ToDomainEnumeration <SchemeStatus>());
await context.SaveChangesAsync();
return(message.PcsId);
}
throw new InvalidOperationException(string.Format("Scheme with Id '{0}' does not exist", message.PcsId));
}