public async Task <IEnumerable <EmployerAccountUser> > GetAccountUsers(long accountId)
{
var teamMembers = await _accountApiClient.GetAccountUsers(accountId);
var users = teamMembers.Select(model => (EmployerAccountUser)model);
return(users);
}
public async Task <TeamMember> GetUserRoleOnAccount(string accountId, string userId)
{
var accounts = await _client.GetAccountUsers(accountId);
if (accounts == null || !accounts.Any())
{
return(null);
}
var teamMember = accounts.FirstOrDefault(c => c.UserRef.Equals(userId, StringComparison.CurrentCultureIgnoreCase));
if (teamMember == null)
{
return(null);
}
Role usrRoleResult;
Enum.TryParse(teamMember.Role, true, out usrRoleResult);
return(new TeamMember
{
HashedAccountId = accountId,
Email = teamMember.Email,
UserRef = teamMember.UserRef,
Role = usrRoleResult
});
}
private async Task <IEnumerable <ProviderUser> > GetProvider(long ukprn)
{
var users = await _emailService.GetUsersAsync(ukprn);
if (users == null)
{
_logger.Warn($"Can't find and user for provider {ukprn}.");
return(new List <ProviderUser>());
}
var accountUserResult = (await _retryPolicy.ExecuteAndCaptureAsync(() => _providerAccountClient.GetAccountUsers(ukprn)));
var accountUser = accountUserResult.Result?.ToArray();
foreach (var user in users)
{
var u = accountUser
?.FirstOrDefault(m => user.Email.Trim().ToLower() == m.EmailAddress.Trim()
?.ToLower());
user.ReceiveNotifications = u == null || u.ReceiveNotifications;
user.Ukprn = ukprn;
}
return(users);
}
public async Task <IEnumerable <UserDetails> > GetAccountUsers(long accountId)
{
var teamMembers = await _accountApiClient.GetAccountUsers(accountId);
var users = teamMembers.Select <TeamMemberViewModel, UserDetails>(model => model);
return(users);
}
private async Task <IEnumerable <User> > GetAccountUsersForFeedback(long accountId)
{
var users = await _accountApiClient.GetAccountUsers(accountId);
return(users
.Where(au => au.CanReceiveNotifications)
.Select(au => MapTeamMemberToUser(au, accountId)));
}
private async Task <string> getUserRole(EmployerIdentifier employerAccount, string userId)
{
var accounts = await _accountApiClient.GetAccountUsers(employerAccount.AccountId);
if (accounts == null || !accounts.Any())
{
return(null);
}
var teamMember = accounts.FirstOrDefault(c => String.Equals(c.UserRef, userId, StringComparison.CurrentCultureIgnoreCase));
return(teamMember?.Role);
}
private async Task <ICollection <TeamMemberViewModel> > GetAccountTeamMembers(string resultHashedAccountId)
{
try
{
_logger.Debug(
$"{nameof(IAccountApiClient)}.{nameof(_accountApiClient.GetAccountUsers)}(\"{resultHashedAccountId}\");");
var teamMembers = await _accountApiClient.GetAccountUsers(resultHashedAccountId);
return(teamMembers);
}
catch (Exception e)
{
_logger.Error(e, $"Account Team Member with id {resultHashedAccountId} not found");
return(new List <TeamMemberViewModel>());
}
}
public async Task Handle(SendEmailToEmployerCommand message, IMessageHandlerContext context)
{
bool IsOwnerOrTransactor(string role)
{
return(role.Equals(Owner, StringComparison.InvariantCultureIgnoreCase) ||
role.Equals(Transactor, StringComparison.InvariantCultureIgnoreCase));
}
try
{
_logger.LogInformation($"Getting AccountUsers for {message.AccountId}");
var emails = new List <string>();
var users = await _accountApiClient.GetAccountUsers(message.AccountId);
if (string.IsNullOrWhiteSpace(message.EmailAddress))
{
_logger.LogInformation("Sending emails to all AccountUsers who can recieve emails");
emails.AddRange(users.Where(x =>
x.CanReceiveNotifications && !string.IsNullOrWhiteSpace(x.Email) &&
IsOwnerOrTransactor(x.Role))
.Select(x => x.Email));
}
else if (users.Any(x => message.EmailAddress.Equals(x.Email, StringComparison.InvariantCultureIgnoreCase) &&
x.CanReceiveNotifications))
{
_logger.LogInformation("Sending email to the explicit user in message");
emails.Add(message.EmailAddress);
}
if (emails.Any())
{
_logger.LogInformation($"Calling SendEmailCommand for {emails.Count()} emails");
await Task.WhenAll(emails.Select(email =>
context.Send(new SendEmailCommand(message.Template, email, message.Tokens))));
}
else
{
_logger.LogWarning($"No Email Addresses found to send Template {message.Template} for AccountId {message.AccountId}");
}
}
catch (Exception e)
{
_logger.LogError($"Error processing {nameof(SendEmailToEmployerCommand)}", e);
throw;
}
}
private async Task <UserModel> ToUserModel(long accountId)
{
var usersResult = await _retryPolicy.ExecuteAndCaptureAsync(() => _accountApi.GetAccountUsers(accountId));
if (usersResult.Outcome == OutcomeType.Failure)
{
_logger.Error(usersResult.FinalException, $"Unable to get employer users for account: {accountId} from account api");
}
if (usersResult.Result == null || !usersResult.Result.Any())
{
_logger.Warn($"No users found for account: {accountId}");
}
return(new UserModel
{
AccountId = accountId,
Users = usersResult.Result
});
}
public async Task <IEnumerable <MembershipContext> > GetMemberships(string hashedAccountId)
{
try
{
var users = await _accountApiClient.GetAccountUsers(hashedAccountId).ConfigureAwait(false);
return
(users
.Select(m => new MembershipContext
{
HashedAccountId = hashedAccountId,
UserEmail = m.Email,
UserRef = m.UserRef
}));
}
catch (Exception ex)
{
_logger.Warn(ex, $"Unable to find users for account {hashedAccountId}");
return(new List <MembershipContext>());
}
}
public async Task <GetUserAccountRoleResponse> Handle(GetUserAccountRoleQuery request, CancellationToken cancellationToken)
{
var accounts = await _client.GetAccountUsers(request.HashedAccountId);
if (accounts == null || !accounts.Any())
{
return(null);
}
var teamMember = accounts.FirstOrDefault(c => c.UserRef.Equals(request.UserId, StringComparison.CurrentCultureIgnoreCase));
if (teamMember == null)
{
return(null);
}
return(new GetUserAccountRoleResponse()
{
Role = teamMember.Role
});
}
public async Task <ICollection <TeamMemberViewModel> > GetAccountUsers(string accountId)
{
return(await _inner.GetAccountUsers(accountId));
}
