public async Task <List <User> > GetAllAsync()
{
return(await _userRepository
.AsReadOnly()
.Include(_ => _.Countries)
.ProjectTo <User>()
.ToListAsync());
}
public async virtual Task <List <TModel> > GetAllAsync()
{
var list = new List <TModel>();
//ProjectTo would also load all child objects
await GetAllEntities(_entityRepository.AsReadOnly())
.ForEachAsync(e => list.Add(Mapper.Map <TModel>(e)));
return(list);
}
public async Task <bool> ValidateCredentials(string username, string password)
{
var user = await _entityRepository
.AsReadOnly()
.SingleOrDefaultAsync(s => s.UserName == username);
if (user != null)
{
return((String.IsNullOrEmpty(user.PasswordSalt) || String.IsNullOrEmpty(user.PasswordHash)) ? false
: CryptographyService.PasswordValidation(user.PasswordHash, user.PasswordSalt, password));
}
else
{
return(false);
}
}
public async Task <List <Role> > GetAllAsync()
{
return(await _roleRepository
.AsReadOnly()
.ProjectTo <Role>()
.ToListAsync());
}
private async Task AdditionalValidationAsync(UserBase model)
{
var role = await _roleRepository
.AsReadOnly()
.SingleOrDefaultAsync(_ => _.Id == model.RoleId.Value);
//if (role == null || role.ParentRoleId.HasValue != model.ParentUserId.HasValue)
//{
// throw new InvalidModelException(); // TODO: Add error
//}
}
public async Task <IEnumerable <PersistedGrant> > GetAllAsync(string subjectId)
{
return(await GetAllEntities(_entityRepository.AsReadOnly())
.Where(s => s.SubjectId == subjectId)
.ProjectTo <PersistedGrant>()
.ToListAsync());
}
public async Task <bool> SendEmailAsync(string emailAddress, EmailTemplateType templateType, IDictionary <string, string> placeholders = null, IList <string> ccEmails = null, IList <EmailAttachment> attachments = null)
{
var template = await _emailTemplateRepository.AsReadOnly().FirstOrDefaultAsync(_ => _.Type == templateType);
if (template == null)
{
return(false);
}
var subject = template.Subject;
var body = template.Body;
if (placeholders != null)
{
subject = ""; // template.Subject.ReplacePlaceholders(placeholders);
body = ""; // template.Body.ReplacePlaceholders(placeholders);
}
var sent = await _emailSender.SendEmailAsync(emailAddress, subject, body, ccEmails, attachments);
return(sent);
}
public async Task <AuthenticationInfo> AuthenticateAsync(AuthenticationModel model)
{
model.RejectInvalid();
var user = await _userRepository.AsReadOnly().Include(_ => _.Role).SingleOrDefaultAsync(_ => _.UserName == model.UserName);
user.RejectNotFound();
var passwordHash = _cryptographyService.CreateHash(model.Password, user.PasswordSalt);
if (passwordHash != user.PasswordHash)
{
throw new InvalidModelException();
}
TokenData tokenData = null;
try
{
tokenData = Mapper.Map <Entities.User, TokenData>(user);
}
catch (Exception ex)
{
user.RejectInvalid();
}
var tokenTask = _tokenProvider.CreateTokenAsync(tokenData);
var refreshTokenTask = _tokenProvider.CreateRefreshTokenAsync(tokenData);
return(new AuthenticationInfo()
{
UserName = user.UserName,
DisplayName = user.DisplayName,
Token = await tokenTask,
RefreshToken = await refreshTokenTask
});
}
public async Task <IEnumerable <Country> > GetAllActiveAsync()
{
var countryIds = await _userCountryRepository.AsReadOnly().Where(_ => _.UserId == _currentUser.Id).Select(_ => _.CountryId).ToListAsync();
var query = _countriesRepository.AsReadOnly()
.Where(_ => _.IsActive == true);
//if (!_currentUser.IsInAnyRole(new string[] { Entities.Role.DivisionalFD_NAME, Entities.Role.Administrator_NAME }))
//{
// query = query.Where(_ => countryIds.Contains(_.Id));
//}
var result = await query
.ProjectTo <Country>()
.ToListAsync();
return(result);
}
public async virtual Task <List <TModel> > GetAllAsync()
{
return(await GetAllEntities(_entityRepository.AsReadOnly())
.ProjectTo <TModel>()
.ToListAsync());
}
