public async Task JoinOrganisationHandler_UserDoesNotExist_ShouldVerifyAuthorization_AndThrowArgumentException() { A.CallTo(() => userContext.UserId) .Returns(Guid.NewGuid()); A.CallTo(() => dataAccess.DoesUserExist(A <Guid> ._)) .Returns(false); await Assert.ThrowsAnyAsync <ArgumentException>( () => JoinOrganisationHandler().HandleAsync(new JoinOrganisation(Guid.NewGuid()))); A.CallTo(() => weeeAuthorization.EnsureCanAccessExternalArea()) .MustHaveHappened(); }
public async Task <ReturnData> GetReturnData(Guid returnId, bool forSummary) { authorization.EnsureCanAccessExternalArea(); var @return = await returnDataAccess.GetById(returnId); if (@return == null) { throw new ArgumentException($"No return found for return id {returnId}"); } authorization.EnsureOrganisationAccess(@return.Organisation.Id); var annualQuarterWindow = await quarterWindowFactory.GetQuarterWindow(@return.Quarter); var returnNonObligatedValues = await nonObligatedDataAccess.FetchNonObligatedWeeeForReturn(returnId); var returnObligatedReceivedValues = await obligatedDataAccess.FetchObligatedWeeeReceivedForReturn(returnId); var returnObligatedReusedValues = await obligatedDataAccess.FetchObligatedWeeeReusedForReturn(returnId); List <Aatf> aatfs; if (forSummary && @return.ReturnStatus.Equals(EA.Weee.Domain.AatfReturn.ReturnStatus.Submitted)) { aatfs = await aatfDataAccess.FetchAatfByReturnId(@return.Id); } else { aatfs = await aatfDataAccess.FetchAatfByReturnQuarterWindow(@return); } var sentOn = await obligatedDataAccess.FetchObligatedWeeeSentOnForReturnByReturn(returnId); var returnSchemeList = await returnSchemeDataAccess.GetSelectedSchemesByReturnId(returnId); var returnReportsOn = await genericDataAccess.GetManyByExpression(new ReturnReportOnByReturnIdSpecification(returnId)); var currentDate = SystemTime.Now; var systemSettings = await systemDataDataAccess.Get(); if (systemSettings.UseFixedCurrentDate) { currentDate = systemSettings.FixedCurrentDate; } var returnQuarterWindow = new ReturnQuarterWindow(@return, annualQuarterWindow, aatfs, returnNonObligatedValues, returnObligatedReceivedValues, returnObligatedReusedValues, @return.Organisation, sentOn, returnSchemeList, returnReportsOn, currentDate); return(mapper.Map(returnQuarterWindow)); }
public async Task <List <decimal?> > HandleAsync(Request message) { authorization.EnsureCanAccessExternalArea(); authorization.EnsureOrganisationAccess(message.OrganisationsId); return(await dataAccess.FetchNonObligatedWeeeForReturn(message.ReturnId, message.Dcf)); }
public async Task <Guid> HandleAsync(JoinOrganisation message) { authorization.EnsureCanAccessExternalArea(); var userId = userContext.UserId; if (!await dataAccess.DoesUserExist(userId)) { throw new ArgumentException(string.Format("Could not find a user with id {0}", userId)); } if (!await dataAccess.DoesOrganisationExist(message.OrganisationId)) { throw new ArgumentException(string.Format("Could not find an organisation with id {0}", message.OrganisationId)); } var organisationUser = new OrganisationUser(userId, message.OrganisationId, Domain.User.UserStatus.Pending); var result = await dataAccess.JoinOrganisation(organisationUser); if (!result.Successful) { throw new InvalidOperationException(result.ErrorMessage); } return(message.OrganisationId); }
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(AddAatfSite message) { authorization.EnsureCanAccessExternalArea(); Country country = await organisationDetailsDataAccess.FetchCountryAsync(message.AddressData.CountryId); var address = new AatfAddress( message.AddressData.Name, message.AddressData.Address1, message.AddressData.Address2, message.AddressData.TownOrCity, message.AddressData.CountyOrRegion, message.AddressData.Postcode, country); var weeeReused = await genericDataAccess.GetManyByExpression <WeeeReused>(new WeeeReusedByAatfIdAndReturnIdSpecification(message.AatfId, message.ReturnId)); var weeeReusedSite = new WeeeReusedSite( weeeReused.Last(), address); await offSiteDataAccess.Submit(weeeReusedSite); 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 <WeeeSentOnData> HandleAsync(GetWeeeSentOnById message) { authorization.EnsureCanAccessExternalArea(); var weeeSentOnList = new List <WeeeSentOnData>(); var weeeSentOn = await getSentOnAatfSiteDataAccess.GetWeeeSentOnById(message.WeeeSentOnId); if (weeeSentOn == null) { return(null); } var amount = await fetchWeeeSentOnAmountDataAccess.FetchObligatedWeeeSentOnForReturn(weeeSentOn.Id); var weeeSentOnObligatedData = amount.Select(n => new WeeeObligatedData(n.Id, new AatfData(n.WeeeSentOn.Aatf.Id, n.WeeeSentOn.Aatf.Name, n.WeeeSentOn.Aatf.ApprovalNumber, n.WeeeSentOn.Aatf.ComplianceYear), n.CategoryId, n.NonHouseholdTonnage, n.HouseholdTonnage)).ToList(); var weeeSentOnData = new WeeeSentOnData() { SiteAddress = addressMapper.Map(weeeSentOn.SiteAddress), Tonnages = weeeSentOnObligatedData, WeeeSentOnId = weeeSentOn.Id, SiteAddressId = weeeSentOn.SiteAddress.Id }; if (weeeSentOn.OperatorAddress != null) { weeeSentOnData.OperatorAddress = addressMapper.Map(weeeSentOn.OperatorAddress); weeeSentOnData.OperatorAddressId = weeeSentOn.OperatorAddress.Id; } return(weeeSentOnData); }
public async Task <ReturnData> HandleAsync(GetReturn message) { authorization.EnsureCanAccessExternalArea(); var returnData = await getPopulatedReturn.GetReturnData(message.ReturnId, message.ForSummary); return(returnData); }
public async Task <bool> HandleAsync(RemoveReturnScheme message) { authorization.EnsureCanAccessExternalArea(); await returnSchemeDataAccess.RemoveReturnScheme(message.SchemeIds, message.ReturnId); return(true); }
public async Task <List <ReportOnQuestion> > HandleAsync(GetReportOnQuestion message) { authorization.EnsureCanAccessExternalArea(); var questions = await dataAccess.GetAll <Domain.AatfReturn.ReportOnQuestion>(); return(questions.Select(s => new ReportOnQuestion(s.Id, s.Question, s.Description, s.ParentId ?? default(int), s.AlternativeDescription, s.Title)).ToList()); }
public async Task <AatfAddressData> HandleAsync(GetSentOnAatfSite message) { authorization.EnsureCanAccessExternalArea(); var aatfAddress = await getSentOnAatfSiteDataAccess.GetWeeeSentOnSiteAddress(message.WeeeSentOnId); var addressData = mapper.Map(aatfAddress); return(addressData); }
public async Task <AatfData> HandleAsync(GetAatfByIdExternal message) { authorization.EnsureCanAccessExternalArea(); var aatf = await fetchDataAccess.FetchById(message.AatfId); authorization.EnsureOrganisationAccess(aatf.Organisation.Id); return(mapper.Map(aatf)); }
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 async Task <List <SchemeData> > HandleAsync(GetSchemesExternal message) { authorization.EnsureCanAccessExternalArea(); var schemes = await dataAccess.GetCompleteSchemes(); return(schemes.Where(s => (s.SchemeStatus == SchemeStatus.Approved) || (s.SchemeStatus == SchemeStatus.Withdrawn)) .Select(s => schemeMap.Map(s)) .OrderBy(sd => sd.SchemeName) .ToList()); }
public async Task <bool> HandleAsync(AddNonObligated message) { authorization.EnsureCanAccessExternalArea(); var aatfReturn = await returnDataAccess.GetById(message.ReturnId); var nonObligatedWeees = mapper.Map(message, aatfReturn); await nonObligatedDataAccess.InsertNonObligatedWeee(message.ReturnId, nonObligatedWeees); return(true); }
public async Task <bool> HandleAsync(EditNonObligated message) { authorization.EnsureCanAccessExternalArea(); var aatfReturn = await returnDataAccess.GetById(message.ReturnId); var idsToAmounts = mapper.Map(message, aatfReturn); await nonObligatedDataAccess.UpdateNonObligatedWeeeAmounts(message.ReturnId, idsToAmounts); return(true); }
public async Task <bool> HandleAsync(EditAatfSite message) { authorization.EnsureCanAccessExternalArea(); Country country = await organisationDetailsDataAccess.FetchCountryAsync(message.AddressData.CountryId); var value = await genericDataAccess.GetById <AatfAddress>(message.AddressData.Id); await offSiteDataAccess.Update(value, message.AddressData, country); return(true); }
public async Task <bool> HandleAsync(EditNonObligated message) { authorization.EnsureCanAccessExternalArea(); foreach (var nonObligatedValue in message.CategoryValues) { var value = await genericDataAccess.GetById <NonObligatedWeee>(nonObligatedValue.Id); await dataAccess.UpdateAmount(value, nonObligatedValue.Tonnage); } return(true); }
public async Task <bool> HandleAsync(EditObligatedReceived message) { authorization.EnsureCanAccessExternalArea(); foreach (var obligatedValue in message.CategoryValues) { var value = await genericDataAccess.GetById <WeeeReceivedAmount>(obligatedValue.Id); await obligatedReceivedDataAccess.UpdateAmounts(value, obligatedValue.HouseholdTonnage, obligatedValue.NonHouseholdTonnage); } return(true); }
public async Task <SchemeDataList> HandleAsync(GetReturnScheme message) { authorization.EnsureCanAccessExternalArea(); var schemeListData = new List <SchemeData>(); var returnSchemeList = await returnSchemeDataAccess.GetSelectedSchemesByReturnId(message.ReturnId); var schemeDataList = returnSchemeList.Select(s => mapper.Map <Scheme, SchemeData>(s.Scheme)).OrderBy(sd => sd.SchemeName).ToList(); var organisation = await returnSchemeDataAccess.GetOrganisationByReturnId(message.ReturnId); return(new SchemeDataList(schemeDataList, mapper.Map <Organisation, OrganisationData>(organisation))); }
public async Task <AddressTonnageSummary> HandleAsync(GetAatfSite message) { authorization.EnsureCanAccessExternalArea(); var addressData = await getAatfSiteDataAccess.GetAddresses(message.AatfId, message.ReturnId); var returnObligatedReusedValues = await getAatfSiteDataAccess.GetObligatedWeeeForReturnAndAatf(message.AatfId, message.ReturnId); var aatfAddressObligatedAmount = new AatfAddressObligatedAmount(addressData, returnObligatedReusedValues); var result = mapper.Map(aatfAddressObligatedAmount); return(result); }
public async Task <bool> HandleAsync(AddNonObligated message) { authorization.EnsureCanAccessExternalArea(); var aatfReturn = await returnDataAccess.GetById(message.ReturnId); var nonObligatedWee = new List <NonObligatedWeee>(); foreach (var categoryValue in message.CategoryValues) { nonObligatedWee.Add(new NonObligatedWeee(aatfReturn, categoryValue.CategoryId, message.Dcf, categoryValue.Tonnage)); } await nonObligatedDataAccess.Submit(nonObligatedWee); return(true); }
public async Task <bool> HandleAsync(RemoveAatfSite message) { authorization.EnsureCanAccessExternalArea(); var site = await genericDataAccess.GetById <AatfAddress>(message.SiteId); var weeeReusedSiteId = (await genericDataAccess.GetSingleByExpression <WeeeReusedSite>(new WeeeReusedByAddressIdSpecification(message.SiteId))).Id; var weeeReusedSite = await genericDataAccess.GetById <WeeeReusedSite>(weeeReusedSiteId); genericDataAccess.Remove(weeeReusedSite); genericDataAccess.Remove(site); await context.SaveChangesAsync(); return(true); }
public async Task <List <Guid> > HandleAsync(AddReturnScheme message) { authorization.EnsureCanAccessExternalArea(); var @return = await returnDataAccess.GetById(message.ReturnId); var returnSchemes = new List <ReturnScheme>(); foreach (var schemeId in message.SchemeIds) { var scheme = await schemeDataAccess.GetSchemeOrDefault(schemeId); returnSchemes.Add(new ReturnScheme(scheme, @return)); } return(await returnSchemeDataAccess.Submit(returnSchemes)); }
public async Task <bool> HandleAsync(AddObligatedSentOn message) { authorization.EnsureCanAccessExternalArea(); var weeeSent = await genericDataAccess.GetById <WeeeSentOn>(message.WeeeSentOnId); var aatfWeeeSentOnAmount = new List <WeeeSentOnAmount>(); foreach (var categoryValue in message.CategoryValues) { aatfWeeeSentOnAmount.Add(new WeeeSentOnAmount(weeeSent, categoryValue.CategoryId, categoryValue.HouseholdTonnage, categoryValue.NonHouseholdTonnage)); } await obligatedSentOnDataAccess.Submit(aatfWeeeSentOnAmount); return(true); }
public async Task <ReturnsData> HandleAsync(GetReturns message) { authorization.EnsureCanAccessExternalArea(); var currentDate = SystemTime.UtcNow; var systemSettings = await systemDataDataAccess.Get(); if (systemSettings.UseFixedCurrentDate) { currentDate = systemSettings.FixedCurrentDate; } var @returns = await returnDataAccess.GetByOrganisationId(message.OrganisationId); var quarter = await returnFactory.GetReturnQuarter(message.OrganisationId, message.Facility); var openQuarters = await quarterWindowFactory.GetQuarterWindowsForDate(currentDate); var returnsData = new List <ReturnData>(); foreach (var @return in @returns.Where(p => p.FacilityType.Value == (int)message.Facility)) { returnsData.Add(await getPopulatedReturn.GetReturnData(@return.Id, false)); } var returnOpenQuarters = new List <Core.DataReturns.Quarter>(); foreach (var q in openQuarters) { returnOpenQuarters.Add(new Core.DataReturns.Quarter(q.StartDate.Year, (Core.DataReturns.QuarterType)q.QuarterType)); } Core.AatfReturn.QuarterWindow nextQuarter = null; if (openQuarters.Count > 0) { var latestOpenQuarter = openQuarters.OrderByDescending(p => p.QuarterType).FirstOrDefault(); var nextWindow = await quarterWindowFactory.GetNextQuarterWindow(latestOpenQuarter.QuarterType, latestOpenQuarter.StartDate.Year); nextQuarter = new Core.AatfReturn.QuarterWindow(nextWindow.StartDate, nextWindow.EndDate, (QuarterType)nextWindow.QuarterType); } return(new ReturnsData(returnsData, quarter, returnOpenQuarters, nextQuarter, currentDate)); }
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 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 Task <Guid> HandleAsync(AddReturn message) { authorization.EnsureCanAccessExternalArea(); authorization.EnsureOrganisationAccess(message.OrganisationId); await ValidateReturnMessage(message); var quarter = new Quarter(message.Year, (QuarterType)message.Quarter); var aatfOrganisation = await genericDataAccess.GetById <Organisation>(message.OrganisationId); var type = Enumeration.FromValue <EA.Weee.Domain.AatfReturn.FacilityType>((int)message.FacilityType); var aatfReturn = new Return(aatfOrganisation, quarter, userContext.UserId.ToString(), type); await returnDataAccess.Submit(aatfReturn); return(aatfReturn.Id); }