public async Task <OrchestratorResponse <ReviewOrganisationAddressViewModel> > GetRefreshedOrganisationDetails(string accountLegalEntityPublicHashedId)
{
var currentDetails = await Mediator.SendAsync(new GetAccountLegalEntityRequest
{
AccountLegalEntityId = _accountLegalEntityHashingService.DecodeValue(accountLegalEntityPublicHashedId)
});
var refreshedDetails = await Mediator.SendAsync(new GetOrganisationByIdRequest
{
Identifier = currentDetails.AccountLegalEntity.Identifier,
OrganisationType = currentDetails.AccountLegalEntity.OrganisationType
});
var result = new OrchestratorResponse <ReviewOrganisationAddressViewModel>
{
Data = new ReviewOrganisationAddressViewModel
{
DataSourceFriendlyName = currentDetails.AccountLegalEntity.OrganisationType.GetFriendlyName(),
AccountLegalEntityPublicHashedId = accountLegalEntityPublicHashedId,
OrganisationName = currentDetails.AccountLegalEntity.Name,
OrganisationAddress = currentDetails.AccountLegalEntity.Address,
RefreshedName = refreshedDetails.Organisation.Name,
RefreshedAddress = refreshedDetails.Organisation.Address.FormatAddress(),
}
};
result.Data.UpdatesAvailable = CheckForUpdate(result.Data.OrganisationName, result.Data.RefreshedName, OrganisationUpdatesAvailable.Name) |
CheckForUpdate(result.Data.OrganisationAddress, result.Data.RefreshedAddress, OrganisationUpdatesAvailable.Address);
return(result);
}
public async Task <OrchestratorResponse <ReviewOrganisationAddressViewModel> > GetRefreshedOrganisationDetails(string accountLegalEntityPublicHashedId)
{
var currentDetails = await Mediator.SendAsync(new GetAccountLegalEntityRequest
{
AccountLegalEntityId = _accountLegalEntityHashingService.DecodeValue(accountLegalEntityPublicHashedId)
});
var refreshedDetails = await Mediator.SendAsync(new GetOrganisationByIdRequest
{
Identifier = currentDetails.AccountLegalEntity.Identifier,
OrganisationType = currentDetails.AccountLegalEntity.OrganisationType
});
OrganisationUpdatesAvailable CheckForUpdate(string currentValue, string updatedValue, OrganisationUpdatesAvailable includeIfDifferent)
{
// The address will be stored with leading and trailing spaces removed, so the change comparison will exclude these.
// Also, the names and addresses returned by CH search and get by id are inconsistent. Specifically the spacing within a
// name of address are different. To counter this one or spaces will be considered to be equivalent.
if (!currentValue.IsEquivalent(updatedValue, StringEquivalenceOptions.IgnoreLeadingSpaces | StringEquivalenceOptions.IgnoreTrailingSpaces | StringEquivalenceOptions.MultipleSpacesAreEquivalent))
{
return(includeIfDifferent);
}
return(OrganisationUpdatesAvailable.None);
}
var result = new OrchestratorResponse <ReviewOrganisationAddressViewModel>
{
Data = new ReviewOrganisationAddressViewModel
{
DataSourceFriendlyName = currentDetails.AccountLegalEntity.OrganisationType.GetFriendlyName(),
AccountLegalEntityPublicHashedId = accountLegalEntityPublicHashedId,
OrganisationName = currentDetails.AccountLegalEntity.Name,
OrganisationAddress = currentDetails.AccountLegalEntity.Address,
RefreshedName = refreshedDetails.Organisation.Name,
RefreshedAddress = refreshedDetails.Organisation.Address.FormatAddress(),
}
};
result.Data.UpdatesAvailable = CheckForUpdate(result.Data.OrganisationName, result.Data.RefreshedName, OrganisationUpdatesAvailable.Name) |
CheckForUpdate(result.Data.OrganisationAddress, result.Data.RefreshedAddress, OrganisationUpdatesAvailable.Address);
return(result);
}
protected override async Task HandleCore(RemoveLegalEntityCommand message)
{
var validationResult = await _validator.ValidateAsync(message);
if (!validationResult.IsValid())
{
throw new InvalidRequestException(validationResult.ValidationDictionary);
}
if (validationResult.IsUnauthorized)
{
_logger.Info($"User {message.UserId} tried to remove {message.HashedAccountLegalEntityId} from Account {message.HashedAccountId}");
throw new UnauthorizedAccessException();
}
var accountId = _hashingService.DecodeValue(message.HashedAccountId);
var accountLegalEntityId = _accountLegalEntityHashingService.DecodeValue(message.HashedAccountLegalEntityId);
var agreements = (await _employerAgreementRepository.GetAccountLegalEntityAgreements(accountLegalEntityId)).ToList();
var legalAgreement = agreements.OrderByDescending(a => a.TemplateId).First();
var hashedLegalAgreementId = _hashingService.HashValue(legalAgreement.Id);
var agreement = await _employerAgreementRepository.GetEmployerAgreement(legalAgreement.Id);
if (agreements.Any(x => x.SignedDate.HasValue))
{
await ValidateLegalEntityHasNoCommitments(agreement, accountId, validationResult);
}
await _employerAgreementRepository.RemoveLegalEntityFromAccount(legalAgreement.Id);
await Task.WhenAll(
AddAuditEntry(accountId, hashedLegalAgreementId),
CreateEvent(hashedLegalAgreementId)
);
// it appears that an agreement is created whenever we create a legal entity, so there should always be an agreement associated with a legal entity
if (agreement != null)
{
var agreementSigned = agreement.Status == EmployerAgreementStatus.Signed;
var caller = await _membershipRepository.GetCaller(accountId, message.UserId);
var createdByName = caller.FullName();
await PublishLegalEntityRemovedMessage(
accountId,
legalAgreement.Id,
agreementSigned,
createdByName,
agreement.LegalEntityId,
agreement.LegalEntityName,
agreement.AccountLegalEntityId,
message.UserId);
}
}
private long GetAccountLegalEntityId(NameValueCollection parameters)
{
try
{
var accountLegalEntityPublicHashedId = parameters[RouteDataKeys.EmployerAccountLegalEntityPublicHashedId];
if (accountLegalEntityPublicHashedId == null)
{
throw new Exception("AuthorizationContextProvider error - Unable to extract AccountLegalEntityId");
}
return(_accountLegalEntityPublicHashingService.DecodeValue(accountLegalEntityPublicHashedId));
}
catch (Exception ex)
{
_log.Warn(ex, "Unable to extract AccountLegalEntityId");
}
throw new Exception("AuthorizationContextProvider error - Unable to extract AccountLegalEntityId");
}
public async Task <GetOrganisationAgreementsResponse> Handle(GetOrganisationAgreementsRequest message)
{
var validationResult = await _validator.ValidateAsync(message);
if (!validationResult.IsValid())
{
throw new InvalidRequestException(validationResult.ValidationDictionary);
}
var accountLegalEntityId = _accountLegalEntityPublicHashingService.DecodeValue(message.AccountLegalEntityHashedId);
var accountLegalEntity = await _employerAgreementRepository.GetOrganisationsAgreements(accountLegalEntityId);
if (accountLegalEntity == null)
{
return(new GetOrganisationAgreementsResponse());
}
var organisationLookupByIdPossible = await _referenceDataService.IsIdentifiableOrganisationType(accountLegalEntity.LegalEntity.Source);
var employerAgreements = accountLegalEntity.Agreements.Where(x => x.StatusId == EmployerAgreementStatus.Pending || x.SignedDate.HasValue).ToList();
var agreements = _mapper.Map <ICollection <EmployerAgreement>, ICollection <EmployerAgreementDto> >
(employerAgreements,
opt =>
{
opt.AfterMap((src, dest) =>
{
dest.ToList().ForEach(e =>
{
e.HashedAccountId = _hashingService.HashValue(accountLegalEntity.AccountId);
e.HashedAgreementId = _hashingService.HashValue(e.Id);
e.HashedLegalEntityId = _hashingService.HashValue(accountLegalEntity.Id);
e.OrganisationLookupPossible = organisationLookupByIdPossible;
});
});
});
return(new GetOrganisationAgreementsResponse {
Agreements = agreements.OrderByDescending(a => a.TemplateId).ToList()
});
}
public async Task <GetAccountLegalEntityRemoveResponse> Handle(GetAccountLegalEntityRemoveRequest message)
{
var validationResult = await _validator.ValidateAsync(message);
if (!validationResult.IsValid())
{
throw new InvalidRequestException(validationResult.ValidationDictionary);
}
if (validationResult.IsUnauthorized)
{
throw new UnauthorizedAccessException();
}
var accountId = _hashingService.DecodeValue(message.HashedAccountId);
var accountLegalEntityId = _accountLegalEntityHashingService.DecodeValue(message.HashedAccountLegalEntityId);
var accountLegalEntity = await _employerAgreementRepository.GetAccountLegalEntity(accountLegalEntityId);
var result = await _employerAgreementRepository.GetAccountLegalEntityAgreements(accountLegalEntityId);
if (result == null)
{
return(new GetAccountLegalEntityRemoveResponse());
}
if (result.Any(x => x.SignedDate.HasValue))
{
return(new GetAccountLegalEntityRemoveResponse
{
CanBeRemoved = await SetRemovedStatusBasedOnCommitments(accountId, accountLegalEntity),
HasSignedAgreement = true,
Name = accountLegalEntity.Name
});
}
return(new GetAccountLegalEntityRemoveResponse
{
CanBeRemoved = true,
HasSignedAgreement = false,
Name = accountLegalEntity.Name
});
}
