public async Task <GetLegalEntitiesForEmployerResult> Handle(GetLegalEntitiesForEmployerQuery request, CancellationToken cancellationToken)
{
var resourceListResponse = await _accountsApiClient.Get <AccountDetail>(
new GetAllEmployerAccountLegalEntitiesRequest(request.EncodedAccountId));
var legalEntities = new List <GetEmployerAccountLegalEntityItem>();
if (resourceListResponse == null)
{
return(new GetLegalEntitiesForEmployerResult
{
LegalEntities = legalEntities
});
}
foreach (var resource in resourceListResponse.LegalEntities)
{
var accountLegalEntityItem = await _accountsApiClient.Get <GetEmployerAccountLegalEntityItem>(
new GetEmployerAccountLegalEntityRequest(resource.Href));
if (accountLegalEntityItem.Agreements.Any(c => c.Status == EmployerAgreementStatus.Signed))
{
accountLegalEntityItem.AccountPublicHashedId = request.EncodedAccountId;
accountLegalEntityItem.AccountName = resourceListResponse.DasAccountName;
legalEntities.Add(accountLegalEntityItem);
}
}
return(new GetLegalEntitiesForEmployerResult
{
LegalEntities = legalEntities
});
}
public async Task <GetAccountResult> Handle(GetAccountQuery request, CancellationToken cancellationToken)
{
var result = await _apiClient.Get <GetAccountResponse>(new GetAccountRequest(request.HashedAccountId));
if (result == null)
{
return(null);
}
return(new GetAccountResult
{
AccountId = result.AccountId,
HashedAccountId = result.HashedAccountId,
PublicHashedAccountId = result.PublicHashedAccountId,
DasAccountName = result.DasAccountName,
DateRegistered = result.DateRegistered,
OwnerEmail = result.OwnerEmail,
Balance = result.Balance,
RemainingTransferAllowance = result.RemainingTransferAllowance,
StartingTransferAllowance = result.StartingTransferAllowance,
AccountAgreementType = result.AccountAgreementType,
ApprenticeshipEmployerType = result.ApprenticeshipEmployerType,
IsAllowedPaymentOnService = result.IsAllowedPaymentOnService
});
}
public async Task <GetAccountQueryResult> Handle(GetAccountQuery request, CancellationToken cancellationToken)
{
var result = await _apiClient.Get <GetAccountByIdResponse>(new GetAccountByIdRequest(request.AccountId));
if (result == null)
{
return(new GetAccountQueryResult());
}
return(new GetAccountQueryResult
{
AccountId = result.AccountId,
HashedAccountId = result.HashedAccountId
});
}
public async Task <GetAccountUsersResult> Handle(GetAccountUsersQuery request, CancellationToken cancellationToken)
{
var result = await _apiClient.Get <GetAccountUsersResponse>(new GetAccountUsersRequest(request.HashedAccountId));
if (result == null)
{
return(null);
}
return(new GetAccountUsersResult(request.HashedAccountId, result.Select(x => new TeamMember
{
UserRef = x.UserRef,
Name = x.Name,
Email = x.Email,
Role = x.Role,
CanReceiveNotifications = x.CanReceiveNotifications,
Status = x.Status
})));
}
public async Task <LegalEntity> GetLegalEntity(string accountId, long legalEntityId)
{
var response = await _client.Get <LegalEntity>(new GetLegalEntityRequest(accountId, legalEntityId));
return(response);
}
public async Task <AccountLegalEntityItem> GetAccountLegalEntity(AccountIdentifier accountIdentifier, string accountLegalEntityPublicHashedId)
{
switch (accountIdentifier.AccountType)
{
case AccountType.Provider:
var providerResponse =
await _providerRelationshipsApiClient.Get <GetProviderAccountLegalEntitiesResponse>(
new GetProviderAccountLegalEntitiesRequest(accountIdentifier.Ukprn));
if (providerResponse == null)
{
return(null);
}
var legalEntityItem = providerResponse.AccountProviderLegalEntities
.FirstOrDefault(c => c.AccountLegalEntityPublicHashedId.Equals(
accountLegalEntityPublicHashedId, StringComparison.CurrentCultureIgnoreCase));
if (legalEntityItem != null)
{
return(new AccountLegalEntityItem
{
Name = legalEntityItem.AccountLegalEntityName,
AccountLegalEntityPublicHashedId = legalEntityItem.AccountLegalEntityPublicHashedId,
AccountHashedId = legalEntityItem.AccountHashedId
});
}
else
{
return(null);
}
case AccountType.Employer:
var resourceListResponse = await _accountsApiClient.Get <AccountDetail>(
new GetAllEmployerAccountLegalEntitiesRequest(accountIdentifier.AccountHashedId));
if (resourceListResponse == null)
{
return(null);
}
foreach (var legalEntity in resourceListResponse.LegalEntities)
{
var legalEntityResponse =
await _accountsApiClient.Get <GetEmployerAccountLegalEntityItem>(
new GetEmployerAccountLegalEntityRequest(legalEntity.Href));
if (legalEntityResponse.AccountLegalEntityPublicHashedId.Equals(accountLegalEntityPublicHashedId, StringComparison.CurrentCultureIgnoreCase))
{
return(new AccountLegalEntityItem
{
Name = legalEntityResponse.AccountLegalEntityName,
AccountLegalEntityPublicHashedId = legalEntityResponse.AccountLegalEntityPublicHashedId,
AccountHashedId = accountIdentifier.AccountHashedId
});
}
}
return(null);
default:
return(null);
}
}
public async Task <Account> GetAccount(string encodedAccountId)
{
var response = await _client.Get <Account>(new GetAccountRequest(encodedAccountId));
return(response);
}
