public async Task <IEnumerable <LegalEntityModel> > Get(string accountId)
{
try
{
var id = _hashingService.DecodeValue(accountId);
var url = OuterApiRoutes.LegalEntities.GetLegalEntities(id);
using var response = await _client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead);
if (response.StatusCode == System.Net.HttpStatusCode.NotFound)
{
return(new List <LegalEntityModel>());
}
response.EnsureSuccessStatusCode();
var data = await JsonSerializer.DeserializeAsync <IEnumerable <LegalEntityDto> >(await response.Content.ReadAsStreamAsync(), options : new JsonSerializerOptions {
PropertyNameCaseInsensitive = true
});
return(data.ToLegalEntityModel(_hashingService));
}
catch (IndexOutOfRangeException) // invalid hashed id
{
return(new List <LegalEntityModel>());
}
}
public async Task <Apprenticeship> MapFromAsync(ApprenticeshipViewModel viewModel)
{
var apprenticeship = new Apprenticeship
{
CommitmentId = _hashingService.DecodeValue(viewModel.HashedCommitmentId),
Id = string.IsNullOrWhiteSpace(viewModel.HashedApprenticeshipId) ? 0L : _hashingService.DecodeValue(viewModel.HashedApprenticeshipId),
FirstName = viewModel.FirstName,
LastName = viewModel.LastName,
DateOfBirth = viewModel.DateOfBirth.DateTime,
NINumber = viewModel.NINumber,
ULN = viewModel.ULN,
Cost = viewModel.Cost == null ? default(decimal?) : decimal.Parse(viewModel.Cost),
StartDate = viewModel.StartDate.DateTime,
EndDate = viewModel.EndDate.DateTime,
ProviderRef = viewModel.ProviderRef,
EmployerRef = viewModel.EmployerRef
};
if (!string.IsNullOrWhiteSpace(viewModel.TrainingCode))
{
var training = await GetTrainingProgramme(viewModel.TrainingCode);
apprenticeship.TrainingType = training is Standard ? TrainingType.Standard : TrainingType.Framework;
apprenticeship.TrainingCode = viewModel.TrainingCode;
apprenticeship.TrainingName = training.Title;
}
return(apprenticeship);
}
public async Task Cancel(string accountLegalEntityId, IEnumerable <ApprenticeshipIncentiveModel> apprenticeshipIncentives,
string hashedAccountId, string emailAddress)
{
var decodedAccountLegalEntityId = _hashingService.DecodeValue(accountLegalEntityId);
var url = $"withdrawals";
var serviceRequest = new ServiceRequest()
{
TaskId = Guid.NewGuid().ToString(),
TaskCreatedDate = DateTime.UtcNow
};
foreach (var apprenticeshipIncentive in apprenticeshipIncentives)
{
var request = new WithdrawRequest(
WithdrawalType.Employer,
decodedAccountLegalEntityId,
apprenticeshipIncentive.Uln,
serviceRequest,
_hashingService.DecodeValue(hashedAccountId),
emailAddress
);
using var response = await _client.PostAsJsonAsync(url, request);
response.EnsureSuccessStatusCode();
}
}
protected override async Task HandleCore(SignEmployerAgreementCommand message)
{
var validationResult = await _validator.ValidateAsync(message);
if (!validationResult.IsValid())
{
throw new InvalidRequestException(validationResult.ValidationDictionary);
}
var owner = await _membershipRepository.GetCaller(message.HashedAccountId, message.ExternalUserId);
if (owner == null || owner.Role != Role.Owner)
{
throw new UnauthorizedAccessException();
}
var agreementId = _hashingService.DecodeValue(message.HashedAgreementId);
var signedAgreementDetails = new Models.EmployerAgreement.SignEmployerAgreement
{
SignedDate = message.SignedDate,
AgreementId = agreementId,
SignedById = owner.UserId,
SignedByName = $"{owner.FirstName} {owner.LastName}"
};
await _employerAgreementRepository.SignAgreement(signedAgreementDetails);
var accountId = _hashingService.DecodeValue(message.HashedAccountId);
await AddAuditEntry(message, accountId, agreementId);
var agreement = await _employerAgreementRepository.GetEmployerAgreement(agreementId);
await _employerAgreementRepository.EvaluateEmployerLegalEntityAgreementStatus(accountId, agreement.LegalEntityId);
var hashedLegalEntityId = _hashingService.HashValue((long)agreement.LegalEntityId);
var agreementEvent = _agreementEventFactory.CreateSignedEvent(message.HashedAccountId, hashedLegalEntityId, message.HashedAgreementId);
var genericEvent = _genericEventFactory.Create(agreementEvent);
await _mediator.SendAsync(new PublishGenericEventCommand { Event = genericEvent });
var commitments = await _commitmentService.GetEmployerCommitments(accountId);
var accountHasCommitments = commitments?.Any() ?? false;
await PublishAgreementSignedMessage(accountId, agreement.LegalEntityId, agreement.LegalEntityName, agreementId, accountHasCommitments, owner.FullName(), owner.UserRef);
await _agreementService.RemoveFromCacheAsync(accountId);
}
private async Task <bool> UniqueUln(ApprenticeshipViewModel viewModel, string uln, PropertyValidatorContext arg3, CancellationToken arg4)
{
var id = viewModel.HashedApprenticeshipId == null ? 0 : _hashingService.DecodeValue(viewModel.HashedApprenticeshipId);
var commitmentId = _hashingService.DecodeValue(viewModel.HashedCommitmentId);
var cohort = await _mediator.Send(new GetCommitmentQueryRequest
{
CommitmentId = commitmentId,
ProviderId = viewModel.ProviderId
});
return(cohort.Commitment.Apprenticeships.All(existing => existing.Id == id || existing.ULN != uln));
}
public async Task <DataLockMismatchViewModel> GetApprenticeshipMismatchDataLock(long providerId, string hashedApprenticeshipId)
{
var apprenticeshipId = _hashingService.DecodeValue(hashedApprenticeshipId);
_logger.Info($"Getting apprenticeship datalock for provider: {providerId}", providerId: providerId, apprenticeshipId: apprenticeshipId);
var datalockSummary = await _mediator.Send(new GetApprenticeshipDataLockSummaryQueryRequest
{
ProviderId = providerId,
ApprenticeshipId = apprenticeshipId
});
var data = await _mediator.Send(new GetApprenticeshipQueryRequest
{
ProviderId = providerId,
ApprenticeshipId = apprenticeshipId
});
var commitmentData = await _mediator.Send(new GetCommitmentQueryRequest
{
ProviderId = providerId,
CommitmentId = data.Apprenticeship.CommitmentId
});
var priceHistory = await _mediator.Send(new GetApprenticeshipPriceHistoryQueryRequest
{
ProviderId = providerId,
ApprenticeshipId = apprenticeshipId
});
var datalockSummaryViewModel = await _dataLockMapper.MapDataLockSummary(datalockSummary.DataLockSummary, data.Apprenticeship.HasHadDataLockSuccess);
var dasRecordViewModel = _apprenticeshipMapper.MapApprenticeship(data.Apprenticeship, commitmentData.Commitment);
var priceDataLocks = datalockSummaryViewModel
.DataLockWithCourseMismatch
.Concat(datalockSummaryViewModel.DataLockWithOnlyPriceMismatch)
.Where(m => m.DataLockErrorCode.HasFlag(DataLockErrorCode.Dlock07))
.OrderBy(x => x.IlrEffectiveFromDate);
return(new DataLockMismatchViewModel
{
ProviderId = providerId,
HashedApprenticeshipId = hashedApprenticeshipId,
DasApprenticeship = dasRecordViewModel,
DataLockSummaryViewModel = datalockSummaryViewModel,
EmployerName = data.Apprenticeship.LegalEntityName,
PriceDataLocks = _dataLockMapper.MapPriceDataLock(priceHistory.History, priceDataLocks),
CourseDataLocks = _dataLockMapper.MapCourseDataLock(dasRecordViewModel, datalockSummaryViewModel.DataLockWithCourseMismatch, data.Apprenticeship, priceHistory.History)
});
}
private async Task <IList <Types.Commitment.TransferRequestSummary> > GetTransferRequestsForSender(string hashedTransferSenderId)
{
var transferSenderId = _hashingService.DecodeValue(hashedTransferSenderId);
_logger.Trace($"Getting transfer requests employer sender account {transferSenderId}", accountId: transferSenderId);
var response = await _mediator.SendAsync(new GetTransferRequestsForSenderRequest
{
TransferSenderAccountId = transferSenderId
});
_logger.Info($"Retrieved transfer requests for employer sender account {transferSenderId}. {response.Data.Count} transfer requests found", accountId: transferSenderId);
return(_transferRequestMapper.MapFrom(response.Data, Commitment.TransferType.AsSender).ToList());
}
public async Task <Apprenticeship> MapApprenticeship(ApprenticeshipViewModel vm)
{
var id = string.IsNullOrEmpty(vm.HashedApprenticeshipId)
? 0
: _hashingService.DecodeValue(vm.HashedApprenticeshipId);
var apprenticeship = new Apprenticeship
{
Id = id,
CommitmentId = _hashingService.DecodeValue(vm.HashedCommitmentId),
ProviderId = vm.ProviderId,
FirstName = vm.FirstName,
LastName = vm.LastName,
DateOfBirth = vm.DateOfBirth.DateTime,
NINumber = vm.NINumber,
ULN = vm.ULN,
Cost = vm.Cost.AsNullableDecimal(),
StartDate = vm.StartDate.DateTime,
EndDate = vm.EndDate.DateTime,
PaymentStatus = vm.PaymentStatus,
AgreementStatus = vm.AgreementStatus,
ProviderRef = vm.ProviderRef,
EmployerRef = vm.EmployerRef,
ReservationId = vm.ReservationId
};
if (!string.IsNullOrWhiteSpace(vm.CourseCode))
{
var training = await GetTrainingProgramme(vm.CourseCode);
if (training != null)
{
apprenticeship.TrainingType = int.TryParse(training.CourseCode, out _) ? CommitmentTrainingType.Standard : CommitmentTrainingType.Framework;
apprenticeship.TrainingCode = vm.CourseCode;
apprenticeship.TrainingName = training.Name;
}
else
{
apprenticeship.TrainingType = vm.CourseType;
apprenticeship.TrainingCode = vm.CourseCode;
apprenticeship.TrainingName = vm.CourseName;
_logger.Warn($"Apprentice training course has expired. TrainingName: {apprenticeship.TrainingName}, TrainingCode: {apprenticeship.TrainingCode}, Employer Ref: {apprenticeship.EmployerRef}, ApprenticeshipId: {apprenticeship.Id}, Apprenticeship ULN: {apprenticeship.ULN}");
}
}
return(apprenticeship);
}
public async Task <OrchestratorResponse <SummaryUnsubscribeViewModel> > Unsubscribe(
string userRef,
string hashedAccountId,
string settingUrl)
{
return(await CheckUserAuthorization(
async() =>
{
var accountId = _hashingService.DecodeValue(hashedAccountId);
var settings = await _mediator.SendAsync(new GetUserNotificationSettingsQuery
{
UserRef = userRef
});
var userNotificationSettings = settings.NotificationSettings.SingleOrDefault(m => m.AccountId == accountId);
if (userNotificationSettings == null)
{
throw new InvalidStateException($"Cannot find user settings for user {userRef} in account {accountId}");
}
if (userNotificationSettings.ReceiveNotifications)
{
await _mediator.SendAsync(
new UnsubscribeNotificationCommand
{
UserRef = userRef,
AccountId = accountId,
NotificationSettingUrl = settingUrl
});
_logger.Info("Unsubscribed from alerts for user {userRef} in account {accountId}");
}
else
{
_logger.Info("Already unsubscribed from alerts for user {userRef} in account {accountId}");
}
return new OrchestratorResponse <SummaryUnsubscribeViewModel>
{
Data = new SummaryUnsubscribeViewModel
{
AlreadyUnsubscribed = !userNotificationSettings.ReceiveNotifications,
AccountName = userNotificationSettings.Name
}
};
}, hashedAccountId, userRef));
}
public async Task <IEnumerable <PayeView> > GetPayeSchemsWithEnglishFractionForHashedAccountId(string hashedAccountId)
{
long accountId;
try
{
accountId = _hashingService.DecodeValue(hashedAccountId);
}
catch (IndexOutOfRangeException)
{
throw new InvalidRequestException(
new Dictionary <string, string>
{
{
nameof(hashedAccountId), "Hashed account ID cannot be decoded."
}
}
);
}
var payeSchemes = await _payeRepository.GetPayeSchemesByAccountId(accountId);
if (payeSchemes.Count == 0)
{
return(payeSchemes);
}
await AddEnglishFractionsToPayeSchemes(accountId,
payeSchemes);
return(payeSchemes);
}
public async Task <GetTransferRequestsResponse> Handle(GetTransferRequestsQuery message)
{
var transferRequests = await _employerCommitmentApi.GetTransferRequests(message.AccountHashedId);
var accountIds = transferRequests
.SelectMany(r => new[] { r.HashedSendingEmployerAccountId, r.HashedReceivingEmployerAccountId })
.Select(h => _hashingService.DecodeValue(h))
.ToList();
var accounts = await _db.Value.Accounts
.Where(a => accountIds.Contains(a.Id))
.ProjectTo <AccountDto>(_configurationProvider)
.ToDictionaryAsync(a => a.HashedId);
var transferRequestsData = transferRequests
.Select(r => new TransferRequestDto
{
CreatedDate = r.CreatedOn,
ReceiverAccount = accounts[r.HashedReceivingEmployerAccountId],
SenderAccount = accounts[r.HashedSendingEmployerAccountId],
Status = r.Status,
TransferCost = r.TransferCost,
TransferRequestHashedId = r.HashedTransferRequestId
})
.OrderBy(r => r.ReceiverAccount.Id == message.AccountId.Value ? r.SenderAccount.Name : r.ReceiverAccount.Name)
.ThenBy(r => r.CreatedDate)
.ToList();
return(new GetTransferRequestsResponse
{
TransferRequests = transferRequestsData
});
}
public async Task <GetReservationsResponse> Handle(GetReservationsRequest message)
{
var validationResult = _validator.Validate(message);
if (!validationResult.IsValid())
{
throw new InvalidRequestException(validationResult.ValidationDictionary);
}
long accountId = _hashingService.DecodeValue(message.HashedAccountId);
_logger.Info($"Getting reservations for hashed account id {message.HashedAccountId}");
try
{
return(new GetReservationsResponse
{
Reservations = await _service.Get(accountId)
});
}
catch (Exception ex)
{
_logger.Error(ex, $"Failed to get Reservations for {message.HashedAccountId}");
return(new GetReservationsResponse
{
HasFailed = true
});
}
}
public async Task <GetNextUnsignedEmployerAgreementResponse> Handle(GetNextUnsignedEmployerAgreementRequest 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 pendingAgreementId = await _db.Value.AccountLegalEntities
.Where(x => x.AccountId == accountId && x.PendingAgreementId != null)
.Select(x => x.PendingAgreementId).FirstOrDefaultAsync();
return(new GetNextUnsignedEmployerAgreementResponse
{
HashedAgreementId = pendingAgreementId.HasValue ? _hashingService.HashValue(pendingAgreementId.Value) : null
});
}
public async Task <GetEmployerAgreementByIdResponse> Handle(GetEmployerAgreementByIdRequest message)
{
var validationResult = _validator.Validate(message);
if (!validationResult.IsValid())
{
throw new InvalidRequestException(validationResult.ValidationDictionary);
}
var agreementId = _hashingService.DecodeValue(message.HashedAgreementId);
var agreement = await _employerAgreementRepository.GetEmployerAgreement(agreementId);
if (agreement == null)
{
throw new InvalidRequestException(new Dictionary <string, string> {
{ "Agreement", "The agreement could not be found" }
});
}
agreement.HashedAgreementId = message.HashedAgreementId;
return(new GetEmployerAgreementByIdResponse
{
EmployerAgreement = agreement
});
}
protected override async Task HandleCore(RenameEmployerAccountCommand 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 account = await _accountRepository.GetAccountById(accountId);
var accountPreviousName = account.Name;
await _accountRepository.RenameAccount(accountId, message.NewName);
var owner = await _membershipRepository.GetCaller(message.HashedAccountId, message.ExternalUserId);
await AddAuditEntry(owner.Email, accountId, message.NewName);
await NotifyAccountRenamed(message.HashedAccountId);
await PublishAccountRenamedMessage(
accountId, accountPreviousName, message.NewName, owner.FullName(), owner.UserRef);
}
public async Task <GetEmployerAgreementPdfResponse> Handle(GetEmployerAgreementPdfRequest message)
{
var validationResult = await _validator.ValidateAsync(message);
if (!validationResult.IsValid())
{
throw new InvalidRequestException(validationResult.ValidationDictionary);
}
if (validationResult.IsUnauthorized)
{
throw new UnauthorizedAccessException();
}
var employerAgreementId = _hashingService.DecodeValue(message.HashedLegalAgreementId);
var agreement = await _employerAgreementRepository.GetEmployerAgreement(employerAgreementId);
var file = await _pdfService.SubsituteValuesForPdf($"{agreement.TemplatePartialViewName}.pdf");
return(new GetEmployerAgreementPdfResponse {
FileStream = file
});
}
protected override async Task HandleCore(AddPayeToAccountCommand message)
{
await ValidateMessage(message);
var accountId = _hashingService.DecodeValue(message.HashedAccountId);
await _payeRepository.AddPayeToAccount(
new Paye
{
AccessToken = message.AccessToken,
RefreshToken = message.RefreshToken,
AccountId = accountId,
EmpRef = message.Empref,
RefName = message.EmprefName,
Aorn = message.Aorn
}
);
var userResponse = await _mediator.SendAsync(new GetUserByRefQuery { UserRef = message.ExternalUserId });
await AddAuditEntry(message, accountId);
await AddPayeScheme(message.Empref, accountId, userResponse.User.FullName, userResponse.User.UserRef, message.Aorn, message.EmprefName, userResponse.User.CorrelationId);
await NotifyPayeSchemeAdded(message.HashedAccountId, message.Empref);
}
public async Task <GetEmployerAgreementResponse> Handle(GetEmployerAgreementRequest message)
{
var validationResult = await _validator.ValidateAsync(message);
if (!validationResult.IsValid())
{
throw new InvalidRequestException(validationResult.ValidationDictionary);
}
var agreementId = _hashingService.DecodeValue(message.AgreementId);
var employerAgreement = await _database.Value.Agreements.ProjectTo <AgreementDto>(_configurationProvider)
.SingleOrDefaultAsync(x => x.Id.Equals(agreementId));
if (employerAgreement == null)
{
return(new GetEmployerAgreementResponse());
}
employerAgreement.HashedAccountId = _hashingService.HashValue(employerAgreement.AccountId);
employerAgreement.HashedAgreementId = _hashingService.HashValue(employerAgreement.Id);
employerAgreement.HashedLegalEntityId = _hashingService.HashValue(employerAgreement.LegalEntityId);
if (employerAgreement.StatusId != EmployerAgreementStatus.Signed)
{
employerAgreement.SignedByName = GetUserFullName(message.ExternalUserId);
}
return(new GetEmployerAgreementResponse
{
EmployerAgreement = employerAgreement
});
}
public async Task <FindEmployerAccountLevyDeclarationTransactionsResponse> Handle(FindEmployerAccountLevyDeclarationTransactionsQuery 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 transactions = await _dasLevyService.GetAccountLevyTransactionsByDateRange <LevyDeclarationTransactionLine>
(accountId, message.FromDate, message.ToDate, message.ExternalUserId);
//var transactionDetailSummaries = data.Select(item => new LevyDeclarationTransactionLine
//{
// Amount = item.Amount,
// EmpRef = item.EmpRef,
// TopUp = item.TopUp,
// TransactionDate = item.TransactionDate,
// EnglishFraction = item.EnglishFraction,
// LineAmount = item.LineAmount
//}).ToList();
return(new FindEmployerAccountLevyDeclarationTransactionsResponse
{
Transactions = transactions.ToList(),
Total = transactions.Sum(c => c.LineAmount)
});
}
private static long GetCurrentAccountId(IHashingService hashingService)
{
var hashedAccountId = ScenarioContext.Current["HashedAccountId"] as string;
var accountId = hashingService.DecodeValue(hashedAccountId);
return(accountId);
}
public async Task <GetApprenticeshipsResponse> Handle(GetApprenticeshipsRequest message)
{
var validationResult = _validator.Validate(message);
if (!validationResult.IsValid())
{
throw new InvalidRequestException(validationResult.ValidationDictionary);
}
long accountId = _hashingService.DecodeValue(message.HashedAccountId);
try
{
return(new GetApprenticeshipsResponse
{
Apprenticeships = await _commitmentV2Service.GetApprenticeships(accountId)
});
}
catch (Exception ex)
{
_logger.Error(ex, $"Failed to get Cohorts for {message.HashedAccountId}");
return(new GetApprenticeshipsResponse
{
HasFailed = true
});
}
}
public async Task <SignEmployerAgreementCommandResponse> Handle(SignEmployerAgreementCommand message)
{
await ValidateRequest(message);
var owner = await VerifyUserIsAccountOwner(message);
var userResponse = await _mediator.SendAsync(new GetUserByRefQuery { UserRef = message.ExternalUserId });
var agreementId = _hashingService.DecodeValue(message.HashedAgreementId);
await SignAgreement(message, agreementId, owner);
var agreement = await _employerAgreementRepository.GetEmployerAgreement(agreementId);
var hashedLegalEntityId = _hashingService.HashValue((long)agreement.LegalEntityId);
await Task.WhenAll(
AddAuditEntry(message, agreement.AccountId, agreementId),
_employerAgreementRepository.SetAccountLegalEntityAgreementDetails(agreement.AccountLegalEntityId, null, null, agreement.Id, agreement.VersionNumber),
PublishEvents(message, hashedLegalEntityId, agreement, owner, userResponse.User.CorrelationId)
);
return(new SignEmployerAgreementCommandResponse
{
AgreementType = agreement.AgreementType,
LegalEntityName = agreement.LegalEntityName
});
}
public async Task <GetAccountEmployerAgreementsResponse> Handle(GetAccountEmployerAgreementsRequest 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 agreements = await _db.Value.AccountLegalEntities
.WithSignedOrPendingAgreementsForAccount(accountId)
.ProjectTo <EmployerAgreementStatusDto>(_configurationProvider)
.ToListAsync();
agreements = agreements.PostFixEmployerAgreementStatusDto(_hashingService, accountId).ToList();
return(new GetAccountEmployerAgreementsResponse
{
EmployerAgreements = agreements
});
}
public async Task <FindAccountProviderPaymentsResponse> Handle(FindAccountProviderPaymentsQuery 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 transactions = await _dasLevyService.GetAccountProviderPaymentsByDateRange <PaymentTransactionLine>
(accountId, message.UkPrn, message.FromDate, message.ToDate);
if (!transactions.Any())
{
throw new NotFoundException("No transactions found.");
}
var firstTransaction = transactions.First();
return(new FindAccountProviderPaymentsResponse
{
ProviderName = firstTransaction.ProviderName,
TransactionDate = firstTransaction.TransactionDate,
DateCreated = firstTransaction.DateCreated,
Transactions = transactions.ToList(),
Total = transactions.Sum(c => c.LineAmount)
});
}
public async Task <List <LevySchemeDeclarationUpdatedMessage> > LevyForPeriod(string hashedAccountId, string payrollYear, short payrollMonth)
{
var accountId = _hashingService.DecodeValue(hashedAccountId);
var levydeclarations = await _databaseService.GetAccountLevyDeclarations(accountId, payrollYear, payrollMonth);
if (levydeclarations == null)
{
_logger.Debug($"Account API client returned null for GetLevyDeclarations for account {hashedAccountId}, period: {payrollYear}, {payrollMonth}");
return(null);
}
_logger.Info($"Got {levydeclarations.Count} levy declarations for employer {hashedAccountId}.");
var validLevyDeclarations = levydeclarations
.OrderByDescending(ld => ld.SubmissionDate)
.ToList();
_logger.Info($"Got {validLevyDeclarations.Count} levy declarations for period {payrollYear}, {payrollMonth} for employer {hashedAccountId}.");
return(validLevyDeclarations.Select(levy => new LevySchemeDeclarationUpdatedMessage
{
SubmissionId = levy.SubmissionId,
AccountId = accountId,
CreatedAt = levy.CreatedDate,
CreatedDate = levy.CreatedDate,
EmpRef = levy.EmpRef,
PayrollMonth = levy.PayrollMonth,
PayrollYear = levy.PayrollYear,
LevyDeclaredInMonth = levy.Amount,
SubmissionDate = levy.SubmissionDate,
}).ToList());
}
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.HashedLegalAgreementId} from Account {message.HashedAccountId}");
throw new UnauthorizedAccessException();
}
var accountId = _hashingService.DecodeValue(message.HashedAccountId);
var legalAgreementId = _hashingService.DecodeValue(message.HashedLegalAgreementId);
var agreement = await _employerAgreementRepository.GetEmployerAgreement(legalAgreementId);
await _employerAgreementRepository.RemoveLegalEntityFromAccount(legalAgreementId);
await _agreementService.RemoveFromCacheAsync(accountId);
await AddAuditEntry(accountId, message.HashedLegalAgreementId);
await CreateEvent(message.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,
legalAgreementId,
agreementSigned,
createdByName,
agreement.LegalEntityId,
agreement.LegalEntityName,
agreement.AccountLegalEntityId,
message.UserId);
}
}
public async Task <GetInvitationResponse> Handle(GetInvitationRequest message)
{
var invitation = await _invitationRepository.GetView(_hashingService.DecodeValue(message.Id));
return(new GetInvitationResponse
{
Invitation = invitation
});
}
public async Task <GetAccountTransactionSummaryResponse> Handle(GetAccountTransactionSummaryRequest message)
{
var accountId = _hashingService.DecodeValue(message.HashedAccountId);
var result = await _transactionRepository.GetAccountTransactionSummary(accountId);
return(new GetAccountTransactionSummaryResponse {
Data = result
});
}
public async Task <CreateLegalEntityCommandResponse> Handle(CreateLegalEntityCommand message)
{
var validationResult = await _validator.ValidateAsync(message);
if (!validationResult.IsValid())
{
throw new InvalidRequestException(validationResult.ValidationDictionary);
}
if (validationResult.IsUnauthorized)
{
throw new UnauthorizedAccessException();
}
var owner = await _membershipRepository.GetCaller(message.HashedAccountId, message.ExternalUserId);
var ownerExternalUserId = Guid.Parse(owner.UserRef);
var createParams = new CreateLegalEntityWithAgreementParams
{
AccountId = owner.AccountId,
Name = message.Name,
Status = message.Status,
Code = string.IsNullOrEmpty(message.Code) ? Guid.NewGuid().ToString() : message.Code,
DateOfIncorporation = message.DateOfIncorporation,
PublicSectorDataSource = message.PublicSectorDataSource,
Source = message.Source,
Address = message.Address,
Sector = message.Sector
};
var agreementView = await _accountRepository.CreateLegalEntityWithAgreement(createParams);
agreementView.HashedAgreementId = _hashingService.HashValue(agreementView.Id);
await CreateAuditEntries(owner, agreementView);
await NotifyLegalEntityCreated(message.HashedAccountId, agreementView.LegalEntityId);
var accountId = _hashingService.DecodeValue(message.HashedAccountId);
await EvaluateEmployerLegalEntityAgreementStatus(owner.AccountId, agreementView.LegalEntityId);
agreementView.AccountLegalEntityPublicHashedId = _accountLegalEntityPublicHashingService.HashValue(agreementView.AccountLegalEntityId);
await PublishLegalEntityAddedMessage(accountId, agreementView.Id, createParams.Name, owner.FullName(), agreementView.LegalEntityId,
agreementView.AccountLegalEntityId, agreementView.AccountLegalEntityPublicHashedId, message.Code, message.Address, message.Source, ownerExternalUserId);
await PublishAgreementCreatedMessage(accountId, agreementView.Id, createParams.Name, owner.FullName(), agreementView.LegalEntityId, ownerExternalUserId);
await _agreementService.RemoveFromCacheAsync(accountId);
return(new CreateLegalEntityCommandResponse
{
AgreementView = agreementView
});
}
protected override async Task HandleCore(SignEmployerAgreementCommand message)
{
var validationResult = await _validator.ValidateAsync(message);
if (!validationResult.IsValid())
{
throw new InvalidRequestException(validationResult.ValidationDictionary);
}
var owner = await _membershipRepository.GetCaller(message.HashedAccountId, message.ExternalUserId);
if (owner == null || (Role)owner.RoleId != Role.Owner)
{
throw new UnauthorizedAccessException();
}
var agreementId = _hashingService.DecodeValue(message.HashedAgreementId);
var signedAgreementDetails = new Domain.Models.EmployerAgreement.SignEmployerAgreement
{
SignedDate = message.SignedDate,
AgreementId = agreementId,
SignedById = owner.UserId,
SignedByName = $"{owner.FirstName} {owner.LastName}"
};
await _employerAgreementRepository.SignAgreement(signedAgreementDetails);
var accountId = _hashingService.DecodeValue(message.HashedAccountId);
await AddAuditEntry(message, accountId, agreementId);
var agreement = await _employerAgreementRepository.GetEmployerAgreement(agreementId);
var hashedLegalEntityId = _hashingService.HashValue(agreement.LegalEntityId);
var agreementEvent = _agreementEventFactory.CreateSignedEvent(message.HashedAccountId, hashedLegalEntityId,
message.HashedAgreementId);
var genericEvent = _genericEventFactory.Create(agreementEvent);
await _mediator.SendAsync(new PublishGenericEventCommand { Event = genericEvent });
}
