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);
}
