public async Task <Guid> HandleAsync(UpdateUser query) { authorization.EnsureCanAccessInternalArea(); authorization.EnsureUserInRole(Roles.InternalAdmin); var user = await userManager.FindByIdAsync(query.UserId); if (user == null) { throw new ArgumentException(string.Format("Could not find a user with id {0}", query.UserId)); } user.FirstName = query.FirstName; user.Surname = query.LastName; var result = await userManager.UpdateAsync(user); if (!result.Succeeded) { string message = "User update failed."; throw new Exception(message); } return(new Guid(user.Id)); }
public async Task <Guid> HandleAsync(UpdateCompetentAuthorityUserRoleAndStatus query) { authorization.EnsureCanAccessInternalArea(); authorization.EnsureUserInRole(Roles.InternalAdmin); var competentAuthorityUser = await dataAccess.GetCompetentAuthorityUser(query.Id); if (competentAuthorityUser == null) { string message = string.Format( "No competent authority user was found with ID \"{0}\".", query.Id); throw new InvalidOperationException(message); } if (userContext != null && userContext.UserId.ToString() == competentAuthorityUser.UserId) { throw new InvalidOperationException(string.Format("Error for user with Id '{0}': Users cannot change their own status or role", userContext.UserId)); } var role = await dataAccess.GetRoleOrDefaultAsync(query.RoleName); if (role == null) { throw new InvalidOperationException(string.Format("Invalid role name {0}", query.RoleName)); } await dataAccess.UpdateUserRoleAndStatus(competentAuthorityUser, role, query.UserStatus); return(competentAuthorityUser.CompetentAuthorityId); }
public async Task <bool> HandleAsync(CheckApprovalNumberIsUnique message) { authorization.EnsureCanAccessInternalArea(); authorization.EnsureUserInRole(Roles.InternalAdmin); var existing = await dataAccess.FetchByApprovalNumber(message.ApprovalNumber, message.ComplianceYear); return(existing != null); }
public async Task <CanApprovalDateBeChangedFlags> HandleAsync(CheckAatfApprovalDateChange message) { authorization.EnsureCanAccessInternalArea(); authorization.EnsureUserInRole(Roles.InternalAdmin); var aatf = await aatfDataAccess.GetDetails(message.AatfId); return(await getAatfApprovalDateChangeStatus.Validate(aatf, message.NewApprovalDate)); }
public async Task <List <Role> > HandleAsync(GetRoles message) { authorization.EnsureCanAccessInternalArea(); authorization.EnsureUserInRole(Roles.InternalAdmin); return(await weeeContext.Roles .Select(r => new Role { Name = r.Name, Description = r.Description }) .ToListAsync()); }
public async Task <bool> HandleAsync(UpdateSchemeContactDetails message) { authorization.EnsureInternalOrOrganisationAccess(message.SchemeData.OrganisationId); if (authorization.CheckCanAccessInternalArea()) { authorization.EnsureUserInRole(Roles.InternalAdmin); } var scheme = await dataAccess.FetchSchemeAsync(message.SchemeData.OrganisationId); if (scheme == null) { var errorMessage = $"A scheme with organisation id \"{message.SchemeData.OrganisationId}\" could not be found."; throw new ArgumentException(errorMessage); } var contact = new Contact( message.SchemeData.Contact.FirstName, message.SchemeData.Contact.LastName, message.SchemeData.Contact.Position); var contactChanged = !contact.Equals(scheme.Contact); scheme.AddOrUpdateMainContactPerson(contact); var country = await dataAccess.FetchCountryAsync(message.SchemeData.Address.CountryId); var address = new Address( message.SchemeData.Address.Address1, message.SchemeData.Address.Address2, message.SchemeData.Address.TownOrCity, message.SchemeData.Address.CountyOrRegion, message.SchemeData.Address.Postcode, country, message.SchemeData.Address.Telephone, message.SchemeData.Address.Email); var schemeAddressChanged = !address.Equals(scheme.Address); scheme.AddOrUpdateAddress(address); await dataAccess.SaveAsync(); if (message.SendNotificationOnChange && (contactChanged || schemeAddressChanged) && scheme.CompetentAuthority != null) { await weeeEmailService.SendOrganisationContactDetailsChanged(scheme.CompetentAuthority.Email, scheme.SchemeName, EntityType.Pcs); } return(true); }
public async Task <bool> HandleAsync(CompleteOrganisationAdmin message) { authorization.EnsureCanAccessInternalArea(); authorization.EnsureUserInRole(Roles.InternalAdmin); Organisation organisation = await dataAccess.FetchOrganisationAsync(message.OrganisationId); organisation.OrganisationStatus = OrganisationStatus.Complete; await dataAccess.SaveAsync(); return(true); }
public async Task <AatfDeletionData> HandleAsync(CheckAatfCanBeDeleted message) { authorization.EnsureCanAccessInternalArea(); authorization.EnsureUserInRole(Roles.InternalAdmin); var aatf = await aatfDataAccess.GetDetails(message.AatfId); var aatfDeletion = await getAatfDeletionStatus.Validate(aatf.Id); var organisationDeletion = await getOrganisationDeletionStatus.Validate(aatf.Organisation.Id, aatf.ComplianceYear, aatf.FacilityType); return(new AatfDeletionData(organisationDeletion, aatfDeletion)); }
public async Task <bool> HandleAsync(AddAatf message) { authorization.EnsureCanAccessInternalArea(); authorization.EnsureUserInRole(Roles.InternalAdmin); var siteAddress = addressMapper.Map(message.Aatf.SiteAddress); var organisation = await dataAccess.GetById <Organisation>(message.OrganisationId); var competentAuthority = await commonDataAccess.FetchCompetentAuthority(message.Aatf.CompetentAuthority.Abbreviation); var contact = contactMapper.Map(message.AatfContact); LocalArea localArea = null; PanArea panArea = null; if (message.Aatf.LocalAreaData != null) { localArea = await commonDataAccess.FetchLookup <LocalArea>(message.Aatf.LocalAreaData.Id); } if (message.Aatf.PanAreaData != null) { panArea = await commonDataAccess.FetchLookup <PanArea>(message.Aatf.PanAreaData.Id); } var aatf = new Domain.AatfReturn.Aatf( message.Aatf.Name, competentAuthority, message.Aatf.ApprovalNumber, Enumeration.FromValue <Domain.AatfReturn.AatfStatus>(message.Aatf.AatfStatus.Value), organisation, siteAddress, Enumeration.FromValue <Domain.AatfReturn.AatfSize>(message.Aatf.Size.Value), message.Aatf.ApprovalDate.GetValueOrDefault(), contact, message.Aatf.FacilityType.ToDomainEnumeration <Domain.AatfReturn.FacilityType>(), message.Aatf.ComplianceYear, localArea, panArea, message.AatfId); await dataAccess.Add <Domain.AatfReturn.Aatf>(aatf); return(true); }
public async Task <bool> HandleAsync(DeleteAnAatf message) { authorization.EnsureCanAccessInternalArea(); authorization.EnsureUserInRole(Roles.InternalAdmin); using (var transaction = context.Database.BeginTransaction()) { try { var aatfDeletionStatus = await getAatfDeletionStatus.Validate(message.AatfId); if (!aatfDeletionStatus.HasFlag(CanAatfBeDeletedFlags.CanDelete)) { throw new InvalidOperationException(); } await aatfDataAccess.RemoveAatf(message.AatfId); if (aatfDeletionStatus.HasFlag(CanAatfBeDeletedFlags.CanDeleteOrganisation)) { await organisationDataAccess.Delete(message.OrganisationId); } transaction.Commit(); } catch (Exception ex) { transaction.Rollback(); if (ex.InnerException != null) { throw ex.InnerException; } throw; } finally { transaction.Dispose(); } } return(true); }
public async Task <Guid> HandleAsync(CreateOrganisationAdmin message) { authorization.EnsureCanAccessInternalArea(); authorization.EnsureUserInRole(Roles.InternalAdmin); Organisation organisation = null; switch (message.OrganisationType) { case Core.Organisations.OrganisationType.Partnership: organisation = Organisation.CreatePartnership(message.BusinessName); break; case Core.Organisations.OrganisationType.RegisteredCompany: organisation = Organisation.CreateRegisteredCompany(message.BusinessName, message.RegistrationNumber, message.TradingName); break; case Core.Organisations.OrganisationType.SoleTraderOrIndividual: organisation = Organisation.CreateSoleTrader(message.BusinessName, message.TradingName); break; default: break; } if (organisation == null) { throw new NotImplementedException("This organisation type hasn't been implented"); } Country country = await db.Countries.SingleAsync(c => c.Id == message.Address.CountryId); Address address = ValueObjectInitializer.CreateAddress(message.Address, country); await dataAccess.Add <Address>(address); organisation.AddOrUpdateAddress(AddressType.RegisteredOrPPBAddress, address); Guid id = await dataAccess.Add <Organisation>(organisation); return(id); }
public async Task <IssuePendingChargesResult> HandleAsync(Requests.Charges.IssuePendingCharges message) { authorization.EnsureCanAccessInternalArea(true); authorization.EnsureUserInRole(Roles.InternalAdmin); UKCompetentAuthority authority = await dataAccess.FetchCompetentAuthority(message.Authority); IReadOnlyList <MemberUpload> memberUploads = await dataAccess.FetchSubmittedNonInvoicedMemberUploadsAsync(authority); User issuingUser = await domainUserContext.GetCurrentUserAsync(); InvoiceRun invoiceRun = new InvoiceRun(authority, memberUploads, issuingUser); var result = new IssuePendingChargesResult(); result.Errors = new List <string>(); if (authority.Name == "Environment Agency") { ulong fileId = await GetNextIbisFileId(); IbisFileDataGeneratorResult ibisFileDataGeneratorResult = await ibisFileDataGenerator.CreateFileDataAsync(fileId, invoiceRun); result.Errors.AddRange(ibisFileDataGeneratorResult.Errors); if (result.Errors.Count == 0) { IbisFileData ibisFileData = ibisFileDataGeneratorResult.IbisFileData; invoiceRun.SetIbisFileData(ibisFileData); } } if (result.Errors.Count == 0) { await dataAccess.SaveAsync(invoiceRun); result.InvoiceRunId = invoiceRun.Id; } return(result); }
public async Task <bool> HandleAsync(UpdateOrganisationDetails message) { authorization.EnsureCanAccessInternalArea(); authorization.EnsureUserInRole(Roles.InternalAdmin); Organisation organisation = await dataAccess.FetchOrganisationAsync(message.OrganisationData.Id); switch (message.OrganisationData.OrganisationType) { case Core.Organisations.OrganisationType.RegisteredCompany: organisation.UpdateRegisteredCompanyDetails(message.OrganisationData.Name, message.OrganisationData.CompanyRegistrationNumber, message.OrganisationData.TradingName); break; case Core.Organisations.OrganisationType.Partnership: organisation.UpdatePartnershipDetails(message.OrganisationData.TradingName); break; case Core.Organisations.OrganisationType.SoleTraderOrIndividual: organisation.UpdateSoleTraderDetails(message.OrganisationData.Name, message.OrganisationData.TradingName); break; } Country country = await dataAccess.FetchCountryAsync(message.OrganisationData.BusinessAddress.CountryId); Address address = new Address( message.OrganisationData.BusinessAddress.Address1, message.OrganisationData.BusinessAddress.Address2, message.OrganisationData.BusinessAddress.TownOrCity, message.OrganisationData.BusinessAddress.CountyOrRegion, message.OrganisationData.BusinessAddress.Postcode, country, message.OrganisationData.BusinessAddress.Telephone, message.OrganisationData.BusinessAddress.Email); organisation.AddOrUpdateAddress(AddressType.RegisteredOrPPBAddress, address); await dataAccess.SaveAsync(); return(true); }
public async Task <RemoveProducerResult> HandleAsync(RemoveProducer request) { authorization.EnsureCanAccessInternalArea(); authorization.EnsureUserInRole(Roles.InternalAdmin); var producerSubmissions = await removeProducerDataAccess.GetProducerSubmissionsForRegisteredProducer(request.RegisteredProducerId); foreach (var producerSubmission in producerSubmissions) { if (producerSubmission.MemberUpload.InvoiceRun == null) { producerSubmission.MemberUpload.DeductFromTotalCharges(producerSubmission.ChargeThisUpdate); } } var producer = await removeProducerDataAccess.GetProducerRegistration(request.RegisteredProducerId); producer.Remove(); await removeProducerDataAccess.SaveChangesAsync(); return(new RemoveProducerResult(true)); }
public AuthorizationBuilder AllowRole(Roles role) { A.CallTo(() => fake.EnsureUserInRole(role)).DoesNothing(); A.CallTo(() => fake.CheckUserInRole(role)).Returns(true); return(this); }
public async Task <bool> HandleAsync(EditAatfDetails message) { authorization.EnsureCanAccessInternalArea(); authorization.EnsureUserInRole(Roles.InternalAdmin); using (var transaction = context.BeginTransaction()) { try { var updatedAddress = addressMapper.Map(message.Data.SiteAddress); var existingAatf = await genericDataAccess.GetById <Aatf>(message.Data.Id); var competentAuthority = await commonDataAccess.FetchCompetentAuthority(message.Data.CompetentAuthority.Abbreviation); LocalArea localArea = null; PanArea panArea = null; if (message.Data.LocalAreaDataId.HasValue) { localArea = await commonDataAccess.FetchLookup <LocalArea>(message.Data.LocalAreaDataId.Value); } if (message.Data.PanAreaDataId.HasValue) { panArea = await commonDataAccess.FetchLookup <PanArea>(message.Data.PanAreaDataId.Value); } var updatedAatf = new Aatf( message.Data.Name, competentAuthority, message.Data.ApprovalNumber, Enumeration.FromValue <Domain.AatfReturn.AatfStatus>(message.Data.AatfStatusValue), existingAatf.Organisation, updatedAddress, Enumeration.FromValue <Domain.AatfReturn.AatfSize>(message.Data.AatfSizeValue), message.Data.ApprovalDate.GetValueOrDefault(), existingAatf.Contact, existingAatf.FacilityType, existingAatf.ComplianceYear, localArea, panArea); var existingAddress = await genericDataAccess.GetById <AatfAddress>(existingAatf.SiteAddress.Id); var country = await organisationDetailsDataAccess.FetchCountryAsync(message.Data.SiteAddress.CountryId); await aatfDataAccess.UpdateAddress(existingAddress, updatedAddress, country); if (message.Data.ApprovalDate.HasValue && existingAatf.ApprovalDate.HasValue) { var flags = await getAatfApprovalDateChangeStatus.Validate(existingAatf, message.Data.ApprovalDate.Value); if (flags.HasFlag(CanApprovalDateBeChangedFlags.DateChanged)) { var existingQuarter = await quarterWindowFactory.GetAnnualQuarterForDate(existingAatf.ApprovalDate.Value); var newQuarter = await quarterWindowFactory.GetAnnualQuarterForDate(message.Data.ApprovalDate.Value); var range = Enumerable.Range((int)existingQuarter, (int)newQuarter - 1); await aatfDataAccess.RemoveAatfData(existingAatf, range); } } await aatfDataAccess.UpdateDetails(existingAatf, updatedAatf); context.Commit(transaction); } catch (Exception ex) { transaction.Rollback(); if (ex.InnerException != null) { throw ex.InnerException; } } finally { context.Dispose(transaction); } } return(true); }